home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 43 / Amiga Format CD43 (1999)(Future Publishing)(GB)(Track 1 of 2)[!][issue 1999-09].iso / -serious- / comms / other / ftransapiv / sourcecode / surround.h < prev   
C/C++ Source or Header  |  1999-06-14  |  69KB  |  2,534 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <ctype.h>
  5. #include <math.h>
  6. #include <dos.h>
  7. #include <sys/dir.h>
  8. #include <clib/dos_protos.h>
  9. #include <proto/exec.h>
  10.  
  11. char *Arredondar(char var[256])
  12. {
  13.   /*
  14.   Esta rotina arredonda numeros.
  15.  
  16.   Versao  : 1.0
  17.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  18.     Entrada : Numero a arredondar --> 10.57 (CHAR 256)
  19.   Saida   : Numero arredondado  --> 11    (CHAR 256)
  20.             Arredondar("10.57");
  21.   */
  22.  
  23.   char teste[256];
  24.   float x = 0;
  25.   long int y = 0;
  26.   x = atof(var);
  27.   y = x;
  28.     if((x - y) > 0.5)
  29.         y++;
  30.   sprintf(teste, "%d", y);
  31.   return teste;
  32. }
  33.  
  34. char *Corta(char var[256], char delimitador, int numero) 
  35. {
  36.   /*
  37.   Comando para cortar uma variavel apartir de um delimitador e
  38.   por campo, igual ao CUT do UNIX.
  39.  
  40.   Versao  : 1.0
  41.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  42.                                        0      1      2
  43.   Entrada: A linha em questao  --> cristian:robert:gallas (CHAR 256)
  44.            o delimitador       --> : (CHAR 1)
  45.            e o numero do campo --> 1 (INT)
  46.   Saida  : O campo retirado    --> robert (CHAR 256)
  47.   Erro   : "" (CHAR 256)
  48.            Corta("cristian:robert:gallas", ':' 1);
  49.   */
  50.  
  51.   char teste[256];
  52.   int x, y = 0, z = 0, h = 0;
  53.   for(x = 0; x <= strlen(var); x++)
  54.   {
  55.     teste[y++] = var[x];
  56.     if(var[x] == delimitador || var[x] == '\0' || var[x] == '\n')
  57.     {
  58.       
  59.       if(z++ >= numero) {
  60.         teste[--y] = '\0'; h = 1;
  61.         break; } else {
  62.         teste[0] = '\0'; y = 0; }
  63.       if(var[x] == '\0' || var[x] == '\n')
  64.         break;
  65.     }
  66.   }
  67.   teste[y] = '\0';
  68.   if(h == 0)
  69.     strcpy(teste, "CUTERRO");
  70.   return teste;
  71. }
  72.  
  73. char *ArrumaDataHora(char var[256], char caracter)
  74. {
  75.   /*
  76.   Este comando corrige o formato da data, acrescentando o zero
  77.   nos campos em que forem menor que 2.
  78.  
  79.   Versao  : 1.0
  80.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  81.   Entrada : Hora Completa --> 1:10:6 (CHAR 256)
  82.             Delimitador   --> : (CHAR 1)
  83.   Saida   : Hora Arrumada --> 01:10:06 (CHAR 256)
  84.             ArrumaHora("1:10:6", ':');
  85.   */
  86.  
  87.   char teste[256], hor[30], min[30], seg[30];
  88.   strcpy(hor, Corta(var, caracter, 0));
  89.   strcpy(min, Corta(var, caracter, 1));
  90.   strcpy(seg, Corta(var, caracter, 2));
  91.   strcpy(teste, hor);
  92.   if(strlen(hor) < 2)
  93.     sprintf(hor, "0%s", teste);
  94.   strcpy(teste, min);
  95.   if(strlen(min) < 2)
  96.     sprintf(min, "0%s", teste);
  97.   strcpy(teste, seg);
  98.   if(strlen(seg) < 2)
  99.     sprintf(seg, "0%s", teste);
  100.   if(strcmp(seg, "CUTERRO"))
  101.     sprintf(teste, "%s%c%s%c%s", hor, caracter, min, caracter, seg);
  102.   else
  103.     sprintf(teste, "%s%c%s", hor, caracter, min);
  104.  
  105.   return teste;
  106. }
  107.  
  108. char *RetiraPontas(char var[256], int numero) 
  109. {
  110.   /*
  111.   Este comando retira as pontas da variavel passada
  112.  
  113.   Versao  : 1.0
  114.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  115.   Entrada : Linha a recortar      --> Cristian Gallas (CHAR 256)
  116.             Caracteres a recortar --> 1 (INT)
  117.   Saida   : A linha recortada     --> ristian Galla (CHAR 256)
  118.             RetiraPontas("Cristian Gallas", 1);
  119.   */
  120.  
  121.   char teste[256];
  122.   int x = 0, y = 0; 
  123.   if(strlen(var) < 2)
  124.     return "";
  125.   for(x = numero; x < (strlen(var) - numero); x++)
  126.     teste[y++] = var[x];
  127.  
  128.   teste[y] = '\0';
  129.   return teste;
  130. }
  131.  
  132. char *HoraSegundo(char var[256])
  133. {
  134.   /*
  135.   Este comando recebe uma hora e retorna em segundos
  136.  
  137.   Versao  : 1.0
  138.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  139.   Entrada : Hora:Minutos:Segundos --> 24:59:59 (CHAR 256)
  140.   Saida   : Em Segundos           --> 24234 (LONG)
  141.             HoraSegundo("24:59:59");
  142.   */
  143.  
  144.   char teste[256], hora[50], minutos[50], segundos[50];
  145.   long total;
  146.  
  147.   strcpy(hora,     Corta(var, ':', 0));
  148.   strcpy(minutos,  Corta(var, ':', 1));
  149.   strcpy(segundos, Corta(var, ':', 2));
  150.  
  151.   total = ((atoi(hora) * 3600) + (atoi(minutos) * 60) + atoi(segundos));
  152.   sprintf(teste, "%ld", total);
  153.   return teste;
  154. }
  155.  
  156. char *SegundoHora(char var[256])
  157. {
  158.   /*
  159.   Este comando recebe em segundos e retorna uma hora completa
  160.   
  161.   Versao  : 1.0
  162.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  163.   Entrada : Segundos      --> 456545 (CHAR 256)
  164.   Saida   : Hora Completa --> 24:59:59 (CHAR 256)
  165.             SegundoHora("456545");
  166.   */
  167.  
  168.   char teste[256];
  169.   float total;
  170.   int hor, min, seg;
  171.  
  172.   total = atof(var) / 3600;
  173.   sprintf(teste, "%f", total);
  174.   hor = atoi(Corta(teste, '.', 0));
  175.  
  176.   total = (total - hor) * 60;
  177.   sprintf(teste, "%f", total);
  178.   min = atoi(Corta(teste, '.', 0));
  179.  
  180.   total = (total - min) * 60;
  181.   sprintf(teste, "%f", total);
  182.   seg = atoi(Corta(teste, '.', 0));
  183.  
  184.   sprintf(teste, "%d:%d:%d", hor, min, seg);
  185.   strcpy(teste, ArrumaDataHora(teste, ':'));
  186.   return teste;
  187. }
  188.  
  189. char *IntervaloHora(char var1[256], char var2[256])
  190. {
  191.   /*
  192.   Este comando recebe duas horas "em segundo" e retorna
  193.  
  194.   Versao  : 1.0
  195.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  196.   Entrada : Hora 1 "Em segundo"  --> 12345 (CHAR 256)
  197.             Hora 2 "Em segundo"  --> 54321 (CHAR 256)
  198.   Saida   : Diferenca em Segundo --> 41976 (CHAR 256)
  199.             IntervaloHora("12345", "54321");
  200.   */
  201.  
  202.   char teste[256];
  203.   long total;
  204.  
  205.   total = atoi(var1) - atoi(var2);
  206.  
  207.   if (total < 0)
  208.     total = (total * (-1));
  209.  
  210.   sprintf(teste, "%ld", total);
  211.   return teste;
  212. }
  213.  
  214. int PosicaoCaracter(char var[256], char caracter, int numero)
  215. {
  216.   /*
  217.   Este comando procura dentro de uma string um determinado 
  218.   CARACTER, e devolve sua posicao no string, sempre sera passado
  219.   a primeira ocorrencia partindo da posicao inicial de 1
  220.  
  221.   Versao  : 1.0
  222.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  223.   Entrada : String   --> Cristian Robert Gallas (CHAR 256)
  224.               Caracter --> o (CHAR 1)
  225.             Numero   --> 2 (INT)
  226.   Obs     : O Numero eh o numero de ocorrencias na string. 
  227.             No caso de 2 sera pego a posicao do segundo caracter
  228.             encontrado.
  229.   Saida   : Posicao  --> 11 (INT)
  230.             PosicaoCaracter("Cristian Robert Gallas", 'o', 2);
  231.   */
  232.  
  233.   int x = 0, y = 0;
  234.   for(x = 0; x < strlen(var); x++)
  235.   {
  236.     if(caracter == var[x])
  237.     {
  238.       y++;
  239.       if(y >= numero)
  240.                 break;
  241.     }
  242.   }
  243.   return ++x;
  244. }
  245.  
  246. char *HoraFrase(char var[256])
  247. {
  248.   /*
  249.   Este comando recebe uma hora e transforma em uma frase
  250.  
  251.   Versao  : 1.0
  252.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  253.   Entrada : Hora completa --> 24:59:59 (CHAR 256)
  254.   Saida   : Frase    --> 24 hours, 59 seconds and 50 minutes (CHAR 256)
  255.             HoraFrase("24:59:59);
  256.   */
  257.  
  258.   char teste[256], hor[5], min[5], seg[5];
  259.  
  260.   strcpy(hor, Corta(var, ':', 0));
  261.   strcpy(min, Corta(var, ':', 1));
  262.   strcpy(seg, Corta(var, ':', 2));
  263.  
  264.   sprintf(teste, "%s hours, %s minutes and %s seconds", hor, min, seg);
  265.   return teste;
  266. }
  267.  
  268. char *DiaJuliano(char var[256])
  269. {
  270.   /*
  271.   Este comando recebe uma data e retorna seu dia juliano
  272.  
  273.   Versao  : 1.0
  274.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  275.   Entrada : Dia.Mes.Ano --> 24.05.1997 (CHAR 256)
  276.   Saida   : Dia Juliano --> 354555 (CHAR 256)
  277.             DiaJuliano("24.05.1997");
  278.   */
  279.  
  280.   char teste[256];
  281.   float x = 0, ano = 0, Aux = 0;
  282.   int dia = 0, mes = 0;
  283.   dia = atoi(Corta(var, '.', 0));
  284.   mes = atoi(Corta(var, '.', 1));
  285.   ano = atoi(Corta(var, '.', 2));
  286.   Aux = ((ano - 1) / 4) + ((ano - 1) * 365) + dia;
  287.   switch (mes) 
  288.   {
  289.        case 2: Aux = Aux + 31; break;
  290.        case 3: Aux = Aux + 59; break;
  291.        case 4: Aux = Aux + 90; break;
  292.        case 5: Aux = Aux + 120; break;
  293.        case 6: Aux = Aux + 151; break;
  294.        case 7: Aux = Aux + 181; break;
  295.        case 8: Aux = Aux + 212; break;
  296.        case 9: Aux = Aux + 243; break;
  297.       case 10: Aux = Aux + 273; break;
  298.       case 11: Aux = Aux + 304; break;
  299.       case 12: Aux = Aux + 334; break;
  300.   }
  301.   x = fmod(ano, 4.0);
  302.   if((x == 0) && (mes > 2))
  303.      Aux++;
  304.   sprintf(teste, "%f", Aux);
  305.   return teste;
  306. }
  307.  
  308. char *DiferencaDias(char var1[256], char var2[256])
  309. {
  310.   /*
  311.   Este comando retorna os dias e a diferenca em segundos dos dias
  312.  
  313.   Versao  : 1.0
  314.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  315.   Entrada : Dia.Mes.Ano  --> 24.05.1997 (CHAR 256)
  316.             Dia.Mes.Ano  --> 24.05.1997 (CHAR 256)
  317.   Saida   : Dias Intervalo e Segundos de Intervalo --> 0:0 (CHAR 256)
  318.             DiferencaDias("24.05.1997", "24.05.1997");
  319.   */
  320.  
  321.   char dia1[50], dia2[50], teste[256], dias[20];
  322.   int total;
  323.  
  324.   strcpy(dia1, DiaJuliano(var1));
  325.   strcpy(dia2, DiaJuliano(var2));
  326.  
  327.   total = atoi(dia2) - atoi(dia1);
  328.   sprintf(dias, "%d", total);
  329.   total = total * 86400;
  330.  
  331.   if(total < 0)
  332.     total = 0;
  333.  
  334.   sprintf(teste, "%s:%d", dias, total);
  335.   return teste;
  336. }
  337.  
  338. int ContaVezesCampo(char arquivo[256], char var[256], char delimitador, int numero)
  339. {
  340.   /*
  341.   Este comando retorna o total de vezes que um determinado registro
  342.   eh encontrado no arquivo.
  343.  
  344.   Versao  : 1.0
  345.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  346.   Entrada : Path+Nome do arquivo  --> dh2:tmp/miami.txt (CHAR 256)
  347.             Chave de procura      --> Me Encontre (CHAR 256)
  348.             Delimitador de campos --> , (CHAR 1)
  349.             Numero do campo       --> 2 (INT)
  350.   Saida   : O total de vezes encontrado no arquivo --> 10 (CHAR 256)
  351.   ContaVezesCampo("dh2:tmp/miami.txt", "Me Encontre", ',', 2);
  352.   */
  353.  
  354.   char teste[256], a;
  355.   int x, total;
  356.   FILE *entrada;
  357.  
  358.   if(!(entrada = fopen(arquivo, "r")))
  359.     return -1;
  360.   else 
  361.   {
  362.     x = 0; total = 0;
  363.     while(a = getc(entrada), ! feof(entrada))
  364.     {
  365.       teste[x++] = a;
  366.       if(a == '\n')
  367.       {
  368.         teste[--x] = '\0';
  369.         strcpy(teste, Corta(teste, delimitador, numero));
  370.         if(!(strcmp(var, teste)))
  371.           total++;
  372.  
  373.         teste[0] = '\0';
  374.         x = 0;
  375.       }
  376.     }
  377.     fclose(entrada);
  378.     return total;
  379.   }
  380. }
  381.  
  382. int ExisteIssoCampo(char arquivo[256], char var[256], char delimitador, int numero)
  383. {
  384.   /*
  385.   Este comando verifica se um conteudo de um determinado campo
  386.   existe ou nao, retornando 1 se sim e 0 se nao
  387.  
  388.   Versao  : 1.0
  389.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  390.   Entrada : Path,Nome do arquivo  --> dh2:tmp/miami.txt (CHAR 256)
  391.             Chave de procura      --> Me Encontre (CHAR 256)
  392.             Delimitador de campos --> , (CHAR 1)
  393.             Numero do campo       --> 2 (INT)
  394.   Saida   : Retorna 1 se existe e 0 se nao existe --> 0 (INT)
  395.             ExisteIssoCampo("dh2:tmp/miami.txt", "Me Encontre", ',', 2);
  396.   */
  397.  
  398.   char teste[256], a;
  399.   int x, sim;
  400.   FILE *entrada;
  401.  
  402.   if(!(entrada = fopen(arquivo, "r")))
  403.     return 9;
  404.   else 
  405.   {
  406.     x = 0; sim = 0;
  407.     while(a = getc(entrada), ! feof(entrada))
  408.     {
  409.       teste[x++] = a;
  410.       if(a == '\n')
  411.       {
  412.         teste[--x] = '\0';
  413.         strcpy(teste, Corta(teste, delimitador, numero));
  414.         if(!(strcmp(var, teste)))
  415.         {
  416.           sim = 1;
  417.           break;
  418.         }
  419.         teste[0] = '\0';
  420.         x = 0;
  421.       }
  422.     }
  423.     fclose(entrada);
  424.     return sim;
  425.   }
  426. }
  427.  
  428. char *Copia(char *var, int inicio, int fim) 
  429. {
  430.     /*
  431.     Este comando copia uma determinada palavra, passando como 
  432.     parametro caractere inicial e final para copia
  433.  
  434.     Entrada : Palavra           --> Cristian Robert Gallas (CHAR*)
  435.                      Caracter inicial  --> 2 (INT)
  436.                        Caracter Final    --> 11 (INT)
  437.     Saida   : A palavra cortada --> ristian Ro (CHAR*)
  438.                       copia("Cristian Robert Gallas", 2, 11);
  439.     */
  440.  
  441.     char *teste;
  442.     int x = 0, y = 0;
  443.  
  444.   teste = malloc(strlen(var) + 1);
  445.   teste[0] = '\0';
  446.  
  447.     if(inicio < 1)
  448.         inicio = 1;
  449.   if(fim == -1)
  450.  /*   fim = (strlen(var) + 1); */
  451.     fim = 1000;
  452.  
  453.   inicio--;
  454.     for(x = inicio; x < fim; x++) 
  455.   {
  456.         if(x <= strlen(var))
  457.             teste[y++] = var[x];
  458.   }
  459.  
  460.     teste[y] = '\0';
  461.     return teste;
  462. }
  463.  
  464. int LinhasArquivo(char var[256])
  465. {
  466.   /*
  467.   Este comando conta o numero de linhas de um arquivo
  468.  
  469.   Versao  : 1.0
  470.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  471.   Entrada : Path+Nome Arquivo --> dh2:tmp/gallas.html (CHAR 256)
  472.   Saida   : Numero de linhas  --> 234 (INT)
  473.   Erro    : -1 (INT)
  474.             LinhasArquivo("dh2:tmp/gallas.html");
  475.   */
  476.  
  477.   char a;
  478.   int total = 0;
  479.   FILE *entrada;
  480.   if(!(entrada = fopen(var, "r")))
  481.     return -1;
  482.   else
  483.   {
  484.     while(a = getc(entrada), ! feof(entrada))
  485.       if(a == '\n')
  486.         total++;
  487.  
  488.     fclose(entrada);
  489.     return total;
  490.   }
  491. }
  492.  
  493. char *LinhaNumero(char var[256], int numero)
  494. {
  495.   /*
  496.   Este comando pega de um arquivo uma linha determinada linha.
  497.  
  498.   Versao  : 1.0
  499.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  500.   Entrada : Path+Nome Arquivo --> dh2:tmp/gallas.html (CHAR 256)
  501.             Linha a pegar     --> 10 (INT)
  502.   Saida   : A linha 10 do arq --> SuRRouND RuLeZ! (CHAR 256)
  503.   Erro    : ERRO (CHAR 256)
  504.             LinhaNumero("dh2:tmp/gallas.html", 10);
  505.   */
  506.  
  507.   char teste[256], a;
  508.   int x, y;
  509.   FILE *entrada;
  510.   
  511.   if(!(entrada = fopen(var, "r")))
  512.     return "ERRO";
  513.  
  514.   x = 0; y = 0;
  515.   while(a = getc(entrada), ! feof(entrada))
  516.   {
  517.     teste[x++] = a;
  518.     if(a == '\n')
  519.     {
  520.       y++;
  521.       if(y == numero) {
  522.         teste[--x] = '\0';
  523.         break;
  524.       } else {
  525.         x = 0;
  526.         teste[0] = '\0'; }
  527.     }
  528.   }
  529.   teste[x] = '\0';
  530.   fclose(entrada);
  531.   return teste;
  532. }
  533.  
  534. int ExisteArquivo(char var[256]) 
  535. {
  536.   /*
  537.   Rotina que testa se um arquivo existe.  
  538.  
  539.   Versao  : 1.0
  540.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  541.   Entrada : Path+Nome Arquivo --> dh2:tmp/gallas.txt (CHAR 256)
  542.   Saida   : True (-1) se existir e False (0) se nao existir (INT)
  543.             if(ExisteArquivo("dh2:tmp/gallas.txt"))
  544.   */
  545.  
  546.   FILE *entrada;
  547.   if(!(entrada = fopen(var, "r"))) {
  548.     fclose(entrada);
  549.     return 0;
  550.   } else {
  551.     fclose(entrada);
  552.     return -1; }
  553. }
  554.  
  555. char *SubstituiCaracter(char var[256], char caracter1, char caracter2)
  556. {
  557.   /*
  558.   Este comando substitui em uma determinada string um caracter
  559.   por outro definido na funcao.
  560.  
  561.   Versao  : 1.0
  562.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  563.   Entrada : String              --> Cristian Gallas (CHAR 256)
  564.             Caracter a procurar --> i (CHAR 1)
  565.             Substituir por      --> X (CHAR 1)
  566.   Saida   : String substituida  --> CrXstXan Gallas (CHAR 256)
  567.             SubstituiCaracter("Cristian Gallas", 'i', 'X');
  568.   */        
  569.  
  570.   char teste[256];
  571.   int x = 0, y = 0;
  572.   for(x = 0; x < strlen(var); x++)
  573.     if(var[x] == caracter1)
  574.       teste[y++] = caracter2;
  575.     else
  576.       teste[y++] = var[x];
  577.   teste[y] = '\0';
  578.   return teste;
  579. }
  580.  
  581. char *MediaCampo(char var[256], char delimitador, int numero)
  582. {
  583.   /*
  584.   Este comando faz a media de um determinado campo.
  585.  
  586.   Versao  : 1.0
  587.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  588.   Entrada : Path+Nome Arquivo --> dh2:gallas.txt (CHAR 256)
  589.             Delimitador Campo --> : (CHAR 1)
  590.             Coluna do Campo   --> 0 (INT)
  591.   Saida   : Total do Campo    --> 5465655 (CHAR 256)
  592.             Media do Campo    --> 2323 (CHAR 256)
  593.   Obs     : O separador da saida eh : ex: 5465655:2323
  594.   Erro    : ERRO (CHAR 256)
  595.             MediaCampo("dh2:gallas.txt", ':', 0);
  596.   */
  597.  
  598.   char teste[256], a;
  599.   float totallinhas = 0, total = 0;
  600.   int x = 0;
  601.   FILE *entrada;
  602.   if(!(entrada = fopen(var, "r")))
  603.     return "ERRO";
  604.   totallinhas = LinhasArquivo(var);
  605.   x = 0; total = 0;
  606.   while(a = getc(entrada), ! feof(entrada))
  607.   {
  608.     teste[x++] = a;
  609.     if(a == '\n')
  610.     {
  611.       teste[--x] = '\0';
  612.       total = total + atof(Corta(teste, delimitador, numero));
  613.       teste[0] = '\0';
  614.       x = 0;
  615.     }
  616.   }
  617.   fclose(entrada);
  618.   sprintf(teste, "%f:%f", total, (total / totallinhas));
  619.   return teste;
  620. }
  621.  
  622. char *AposCaracter(char var[256], char caracter, int numero)
  623. {
  624.   /* 
  625.   Este comando separa uma string apartir de um caracter especifico
  626.   e ainda aceita um numero que serve de pulo apos o caracter espec.
  627.  
  628.   Versao  : 1.0
  629.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  630.   Entrada : String   --> Cristian Robert Gallas (CHAR 256)
  631.             Caracter --> t (CHAR 1)
  632.             Numero   --> 1 (INT)
  633.   Saida   : A String apos o caracter --> ian Robert Gallas (CHAR 256)
  634.   Obs     : Se o Numero fosse 2      --> an Robert Gallas (CHAR 256)
  635.             Se o Numero fosse 3      --> n Robert Gallas (CHAR 256)
  636.             AposCaracter("Cristian Robert Gallas", 't', 1);
  637.   */
  638.  
  639.   char teste[256];
  640.   int x = 0, y = 0, h = 0;
  641.   if(numero >= strlen(var))
  642.     numero = 0;
  643.   for(x = 0; x < strlen(var); x++)
  644.   {
  645.     if((y == 0) && (var[x] == caracter))
  646.     {
  647.       x = x + numero;
  648.       y = 1;
  649.     }
  650.     if(y == 1)
  651.       teste[h++] = var[x];
  652.   }
  653.   teste[h] = '\0';
  654.   return teste;
  655. }
  656.  
  657. int DiferencaMes(char var1[30], char var2[30])
  658. {
  659.   /*
  660.   Este comando pega a diferenca de meses entre duas datas
  661.  
  662.   Versao  : 1.0
  663.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  664.   Entrada : Data Um         --> 01.02.1997 (CHAR 30)
  665.             Data Dois       --> 01.10.1997 (CHAR 30)
  666.   Saida   : Numero de Meses --> 8 (INT)
  667.             DiferencaMes("01.02.1997", "01.10.1997");
  668.   */
  669.  
  670.   int difmes, mes1, mes2, ano1, ano2;
  671.   mes1 = atoi(Corta(var1, '.', 1));
  672.   ano1 = atoi(Corta(var1, '.', 2));
  673.   mes2 = atoi(Corta(var2, '.', 1));
  674.   ano2 = atoi(Corta(var2, '.', 2));
  675.   if (ano1 == ano2)
  676.     difmes = mes1 - mes2;
  677.   else
  678.     difmes = (mes1 - mes2) + ((ano1 - ano2) * 12); 
  679.   if(difmes < 0)
  680.     difmes = difmes * (-1);
  681.   return difmes;
  682. }
  683.  
  684. char *DeletaCaracter(char var[256], char caracter)
  685. {
  686.   /*
  687.   Este comando retira de uma string um determinado CARACTER,
  688.   retorna o string filtrado e o numero de caracter`s deletados.
  689.  
  690.   Versao  : 1.0
  691.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  692.   Entrada : String   --> Cristian Robert Gallas
  693.             Caracter --> i
  694.   Saida   : String Filtrada                --> Crstan Robert Gallas
  695.             Numero de Caracteres Deletados --> 2
  696.             DeletaCaracter("Cristian Robert Gallas", 'i');
  697.   */
  698.  
  699.   char teste[256];
  700.   int x = 0, y = 0, total = 0;
  701.   for(x = 0; x < strlen(var); x++)
  702.     if(var[x] != caracter)
  703.       teste[y++] = var[x];
  704.     else 
  705.       total++;
  706.   teste[y] = '\0';
  707.   sprintf(teste, "%s:%d", teste, total);
  708.   return teste;
  709. }
  710.  
  711. char *Copia2(char var[256], int inicio, int fim) 
  712. {
  713.   /*
  714.   Este comando copia uma determinada palavra, passando como 
  715.   parametro o numero do caractere inicial e o numero do caracter
  716.   que se vai andar apos o inicial.
  717.  
  718.   Versao  : 1.0
  719.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  720.   Entrada : Palavra           --> Cristian Robert Gallas (CHAR 256)
  721.             Caracter inicial  --> 2 (INT)
  722.             Caracter Final    --> 6 (INT)
  723.   Saida   : A palavra cortada --> ristia (CHAR 256)
  724.             Copia2("Cristian Robert Gallas", 2, 6);
  725.   */
  726.  
  727.   char teste[256];
  728.   int x = 0, y = 0;
  729.   if(fim > 256)
  730.     fim = 256;
  731.   if(inicio < 1)
  732.     inicio = 1;
  733.   inicio--;
  734.   for(x = inicio; x < (inicio + fim); x++)
  735.     if(x <= strlen(var))
  736.       teste[y++] = var[x];
  737.   teste[y] = '\0';
  738.   return teste;
  739. }
  740.  
  741. char *Esquerda(char var[256], int numero)
  742. {
  743.   /*
  744.   Este comando recorta uma String da esquerda para direita
  745.  
  746.   Versao  : 1.0
  747.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  748.   Entrada : String               --> Cristian (CHAR 256)
  749.             Numero de Caracteres --> 6 (INT)
  750.   Saida   : String cortada       --> Cristi (CHAR 256)
  751.             Esquerda("Cristian", 6);
  752.   */
  753.  
  754.   char teste[256];
  755.   int x = 0, y = 0;
  756.   if (numero > strlen(var))
  757.     numero = strlen(var);
  758.   for(x = 0; x < numero; x++)
  759.     teste[y++] = var[x];
  760.  
  761.   teste[y] = '\0';
  762.   return teste;
  763. }
  764.  
  765. char *Direita(char var[256], int numero)
  766. {
  767.   /*
  768.   Este comando recorta uma String da direita para a esquerda
  769.  
  770.   Versao  : 1.0
  771.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  772.   Entrada : String               --> Cristian (CHAR 256)
  773.             Numero de Caracteres --> 6 (INT)
  774.   Saida   : String cortada       --> istian (CHAR 256)
  775.             Direita("Cristian", 6);
  776.   */
  777.  
  778.   char teste[256];
  779.   int x = 0, y = 0;
  780.   if (numero > strlen(var))
  781.     numero = strlen(var);
  782.   for(x = (strlen(var) - numero); x < strlen(var); x++)
  783.     teste[y++] = var[x];
  784.  
  785.   teste[y] = '\0';
  786.   return teste;
  787. }
  788.  
  789. char *PrimeiroUltimoCampo(char var[256], char caracter, int numero, char caracter2)
  790. {
  791.   /*
  792.   Este comando retira de um arquivo o primeiro e o ultimo campo
  793.   de uma determinada coluna.
  794.  
  795.   Versao  : 1.0
  796.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  797.   Entrada : Path+Nome Arquivo    --> dh2:gallas.txt (CHAR 256)
  798.             Delimitador Campo    --> : (CHAR 1)
  799.             Numero do Campo      --> 2 (INT)
  800.             Delimitador de Saida --> @ (CHAR 1)
  801.   Saida   : Campo da primeira Linha --> Gallas
  802.             Campo da ultima Linha   --> Robert
  803.   Obs     : O formato da SAIDA eh   --> Gallas:Robert (CHAR 256)
  804.   Erro    : ERRO (CHAR 256)
  805.             PrimeiroUltimoCampo("dh2:gallas.txt", ':', 2, '@');
  806.   */
  807.  
  808.   char teste[256], a, campo1[256], campo2[256]; 
  809.   int x, y;
  810.   FILE *entrada;
  811.   if(!(entrada = fopen(var, "r"))) {
  812.     fclose(entrada);
  813.     return "ERRO"; }
  814.   x = 0; y = 0;
  815.   while(a = getc(entrada), ! feof(entrada))
  816.   {
  817.     teste[x++] = a;
  818.     if(a == '\n')
  819.     {
  820.       y++;
  821.       teste[x] = '\0';
  822.       if(y == 1)
  823.         strcpy(campo1, Corta(teste, caracter, numero));
  824.       if(feof(entrada))
  825.       teste[0] = '\0'; x = 0;
  826.     }
  827.   }
  828.   fclose(entrada);
  829.   strcpy(campo2, Corta(teste, caracter, numero));
  830.   sprintf(teste, "%s%c%s", campo1, caracter2, campo2);
  831.   return teste;
  832. }
  833.  
  834. int QtdCaracter(char var[256], char caracter)
  835. {
  836.   /*
  837.   Este comando retorna o numero de caracters encontrados em uma
  838.   determinada String.
  839.  
  840.   Versao  : 1.0
  841.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  842.   Entrada : String            --> Cristian Robert Gallas (CHAR 256)
  843.             Caracter a contar --> a (CHAR 1)
  844.   Saida   : Numero de vezes   --> 3 (INT)
  845.             QtdCaracter("Cristian Robert Gallas", 'a');
  846.   */
  847.  
  848.   int x = 0, total = 0;
  849.   for(x = 0; x < strlen(var); x++)
  850.     if(caracter == var[x])
  851.   total++;
  852.   return total;
  853. }
  854.  
  855. int FiltraCampoParaArquivo(char var[256], char arq1[256], char arq2[256], char caracter, int numero, char caracter2)
  856. {
  857.   /*
  858.   Este comando filtra um determinado campo de um arquivo, e grava
  859.   outro arquivo com o conteudo igual ao argumento passado.
  860.  
  861.   Versao  : 1.0
  862.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  863.   Entrada : String a comparar     --> 01.02.1997 (CHAR 256)
  864.             Arquivo de Entrada    --> dh1:gallas.txt (CHAR 256)
  865.             Arquivo de Saida      --> dh1:filtro.txt (CHAR 256)
  866.             Delimitador do Arquivo Entrada --> , (CHAR 1)
  867.             Numero do Campo       --> 1 (INT)
  868.             Delimitador da String --> . (CHAR 1)
  869.   Saida   : Eh gerado o arquivo de saida com o conteudo da linha toda
  870.   Erro    : -1 (INT) Caso de problema de abrir arquivo entrada, saida
  871.   Obs     : Este comando foi feito para filtrar datas que seguem o
  872.             formato [XX.XX.XX] [01.02.1997], deve ser passado o deli-
  873.             mitador da data, nesse caso eh ., pode ser comparado ate
  874.             3 campos, ex: [ANO], [MES.ANO], [DIA.MES.ANO]. So 3 campos.
  875.             FiltraCampoParaArquivo("01.02.1997", "dh1:gallas.txt",
  876.                                    "dh1:filtro.txt", ',', 1, '.');
  877.   */
  878.  
  879.   char teste[256], a, mes[20];
  880.   int x, opcao;
  881.   FILE *entrada, *saida;
  882.   if(!(entrada = fopen(arq1, "r")))
  883.     return -1;
  884.   if(!(saida = fopen(arq2, "w")))
  885.     return -1;
  886.   opcao = QtdCaracter(var, caracter2);
  887.   x = 0;
  888.   while(a = getc(entrada), ! feof(entrada))
  889.   {
  890.     teste[x++] = a;
  891.     if(a == '\n')
  892.     {
  893.       teste[--x] = '\0';
  894.       if(opcao == 0)
  895.         strcpy(mes, AposCaracter(AposCaracter(Corta(teste, caracter, numero), caracter2, 1), caracter2, 1));
  896.       if(opcao == 1)
  897.         strcpy(mes, AposCaracter(Corta(teste, caracter, numero), caracter2, 1));
  898.       if(opcao == 2)
  899.         strcpy(mes, Corta(teste, caracter, numero));
  900.       if(!(strcmp(var, mes)))
  901.         fprintf(saida, "%s\n", teste);
  902.       teste[0] = '\0'; x = 0;
  903.     }
  904.   }
  905.   fclose(entrada);
  906.   fclose(saida);
  907.   return 0;
  908. }
  909.  
  910. char *MaiorMenorCampo(char arq[256], char caracter, int numero, int opcao)
  911. {
  912.   /*
  913.   Este comando abre um determinado arquivo rastreando um 
  914.   determinado campo e traz somente o maior ou o menor campo.
  915.  
  916.   Versao  : 1.0
  917.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  918.   Entrada : Path+Nome do Arquivo --> dh2:gallas.txt (CHAR 256)
  919.             Delimitador Campo    --> , (CHAR 1)
  920.             Numero do Campo      --> 1 (INT)
  921.           * Tipo de opcao        --> 0 (MENOR) e 1 (MAIOR) (INT)
  922.   Saida   : Campo Maior ou Menor --> 34,56,99,10 (CHAR 256)
  923.   Erro    : ERRO (CHAR 256) Caso o arquivo de entrada nao exista
  924.             MaiorMenorCampo("dh2:gallas.txt", ',', 1, 0);
  925.             MaiorMenorCampo("dh2:gallas.txt", ',', 1, 1);
  926.   */
  927.  
  928.   char teste[256], a, saida[256];
  929.   int x, total, conta;
  930.   FILE *entrada;
  931.   if(!(entrada = fopen(arq, "r")))
  932.     return "ERRO";
  933.   if(opcao < 0 && opcao > 1)
  934.     opcao = 0;
  935.   x = 0; total = 0; conta = 0;
  936.   while(a = getc(entrada), ! feof(entrada))
  937.   {
  938.     teste[x++] = a;
  939.     if(a == '\n')
  940.     {
  941.       teste[--x] = '\0';
  942.       ++conta;
  943.       if(conta == 1)
  944.       {
  945.         total = atoi(Corta(teste, caracter, numero));
  946.         strcpy(saida, teste);
  947.       }
  948.       if(opcao == 0)
  949.       {
  950.         if(atoi(Corta(teste, caracter, numero)) < total)
  951.         {
  952.           strcpy(saida, teste);
  953.           total = atoi(Corta(teste, caracter, numero));
  954.         }
  955.       } else {
  956.         if(atoi(Corta(teste, caracter, numero)) > total)
  957.         {
  958.           strcpy(saida, teste);
  959.           total = atoi(Corta(teste, caracter, numero));
  960.         }
  961.       }
  962.       teste[0] = '\0'; x = 0;
  963.     }
  964.   }
  965.   fclose(entrada);
  966.   if(!(strcmp(saida, "")))
  967.     strcpy(saida, LinhaNumero(arq, 1));
  968.   return saida;
  969. }
  970.  
  971. char *DataHora(int tipo)
  972. {
  973.   /*
  974.   Este comando pega o dia ou hora do sistema Operacional.
  975.  
  976.   Versao  : 1.0
  977.   Compila : AmigaDos
  978.   Entrada : Tipo de Campo --> 0 (INT)
  979.   Obs     : Tipos [0] [DD.MM.AAAA]
  980.                   [1] [MM.AAAA]
  981.                   [2] [MM.DD.AAAA]
  982.                   [3] [AAAA.DD.MM]
  983.                   [4] [AAAA.MM.DD]
  984.                   [5] [HH:MM:SS]
  985.                   [6] [HH:MM]
  986.                   [7] [HHMMSS]
  987.   Saida   : A data Formatada  --> 30.12.1997 (CHAR 20)
  988.             DataHora(0);
  989.             Ou Hora Formatada --> 24:10:05 (CHAR 20)
  990.             DataHora(4);
  991.   */
  992.  
  993.   char teste[256];
  994.   unsigned char clock[8];
  995.   getclk(clock);
  996.   switch (tipo) 
  997.   {
  998.     case 0: sprintf(teste, "%d.%d.%d", clock[3], clock[2], (1980 + clock[1])); return ArrumaDataHora(teste, '.');
  999.     case 1: sprintf(teste, "%d.%d", clock[2], (1980 + clock[1])); return ArrumaDataHora(teste, '.');
  1000.     case 2: sprintf(teste, "%d.%d.%d", clock[2], clock[3], (1980 + clock[1])); return ArrumaDataHora(teste, '.');
  1001.     case 3: sprintf(teste, "%d.%d.%d", (1980 + clock[1]), clock[3], clock[2]); return ArrumaDataHora(teste, '.');
  1002.     case 4: sprintf(teste, "%d.%d.%d", (1980 + clock[1]), clock[2], clock[3]); return ArrumaDataHora(teste, '.');
  1003.     case 5: sprintf(teste, "%d:%d:%d", clock[4], clock[5], clock[6]); return ArrumaDataHora(teste, ':');
  1004.     case 6: sprintf(teste, "%d:%d", clock[4], clock[5]); return ArrumaDataHora(teste, ':');
  1005.     case 7: sprintf(teste, "%d%d%d", clock[4], clock[5], clock[6]); return teste;
  1006.   }
  1007.   return "ERRO";
  1008. }
  1009.  
  1010. char *DescricaoMes(int mes, int opcao)
  1011. {
  1012.   /*
  1013.   Este comando fornece o mes em formato extenso, se passa o
  1014.   numero do mes e a opcao e sera retornado o nome do mes.
  1015.  
  1016.   Versao  : 1.0
  1017.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1018.   Entrada : Numero do mes  --> 2 (INT)
  1019.             Opcao a listar --> 0 (INT)
  1020.   Obs     : Opcao 0 retorna em Portugues e 1 em Ingles.
  1021.   Saida   : Fevereiro (CHAR RETURN)
  1022.   Erro    : ERRO (CHAR RETURN) Mes invalido! < 0 e > 12
  1023.   Obs     : Caso seja necessario abrevidado use:
  1024.             Esquerda(DescricaoMes(2, 0), 3);
  1025.   */
  1026.  
  1027.   switch (mes)
  1028.   {
  1029.     case  1: if(opcao == 0) return "Janeiro"; else return "January";
  1030.     case  2: if(opcao == 0) return "Fevereiro"; else return "February";
  1031.     case  3: if(opcao == 0) return "Marco"; else return "March";
  1032.     case  4: if(opcao == 0) return "Abril"; else return "April";
  1033.     case  5: if(opcao == 0) return "Maio"; else return "May";
  1034.     case  6: if(opcao == 0) return "Junho"; else return "June";
  1035.     case  7: if(opcao == 0) return "Julho"; else return "July";
  1036.     case  8: if(opcao == 0) return "Agosto"; else return "August";
  1037.     case  9: if(opcao == 0) return "Setembro"; else return "September";
  1038.     case 10: if(opcao == 0) return "Outubro"; else return "October";
  1039.     case 11: if(opcao == 0) return "Novembro"; else return "November";
  1040.     case 12: if(opcao == 0) return "Dezembro"; else return "December";
  1041.   }
  1042.   return "ERRO";
  1043. }
  1044.  
  1045. int CopiaArquivo(char var1[256], char var2[256])
  1046. {
  1047.   /*
  1048.   Este comando copia um determinado arquivo.
  1049.  
  1050.   Versao  : 1.0
  1051.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1052.   Entrada : Path+Nome arquivo origem  --> dh2:gallas.txt (CHAR 256)
  1053.             Path+Nome arquivo destino --> dh2:gallas.tmp (CHAR 256)
  1054.   Saida   : -1 Erro abertura na origem ou criacao destino, 0 OK (INT)
  1055.             CopiaArquivo("dh2:gallas.txt", "dh2:gallas.tmp");
  1056.   */
  1057.  
  1058.   char a;
  1059.   FILE *entrada, *saida;
  1060.   if(!(entrada = fopen(var1, "r")))
  1061.     return -1;
  1062.   if(!(saida = fopen(var2, "w")))
  1063.     return -1;
  1064.   while(a = getc(entrada), ! feof(entrada))
  1065.     fputc(a, saida);
  1066.   fclose(entrada);
  1067.   fclose(saida);
  1068.   return 0;
  1069. }
  1070.  
  1071. int MoveArquivo(char var1[256], char var2[256])
  1072. {
  1073.   /*
  1074.   Este comando move um determinado arquivo.
  1075.  
  1076.   Versao  : 1.0
  1077.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1078.   Entrada : Path+Nome arquivo origem  --> dh2:gallas.txt (CHAR 256)
  1079.             Path+Nome arquivo destino --> dh2:gallas.tmp (CHAR 256)
  1080.   Saida   : -1 Erro abertura na origem ou criacao destino, 0 OK (INT)
  1081.             MoveArquivo("dh2:gallas.txt", "dh2:gallas.tmp");
  1082.   */
  1083.  
  1084.   char a;
  1085.   FILE *entrada, *saida;
  1086.   if(!(entrada = fopen(var1, "r")))
  1087.     return -1;
  1088.   if(!(saida = fopen(var2, "w")))
  1089.     return -1;
  1090.   while(a = getc(entrada), ! feof(entrada))
  1091.     fputc(a, saida);
  1092.   fclose(entrada);
  1093.   fclose(saida);
  1094.   remove(var1);
  1095.   return 0;
  1096. }
  1097.  
  1098. int GravaRegistroDB(char arq[256], char var[256], char campo[256], char caracter[10])
  1099. {
  1100.   /*
  1101.   Este comando grava ou adiciona um registro em um arquivo texto,
  1102.   tipo DB!
  1103.  
  1104.   Versao  : 1.0
  1105.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1106.   Entrada : Path+Nome Arquivo --> dh2:sur.db (CHAR 256)
  1107.             Linha a Gravar    --> Cristian Gallas (CHAR 256)
  1108.             Campo do registro --> Nome (CHAR 256)
  1109.             Tipo de Gravacao  --> a (CHAR 10)
  1110.   Obs     : a --> Append, w --> Write (CASE SENSITIVE)
  1111.   Saida   : 0 se o arq a gravar nao tiver permissao, -1 OK (INT)
  1112.   Obs     : Nao deve ser gravado 2 registros com o mesmo campo.
  1113.   GravaRegistroDB("dh2:sur.db", "Cristian Gallas", "Nome", "a");
  1114.   */
  1115.  
  1116.   FILE *saida;
  1117.   if(!(saida = fopen(arq, caracter)))
  1118.     return 0;
  1119.   fprintf(saida, "**>%s:%s\n", campo, var);
  1120.   fclose(saida);
  1121.   return -1;
  1122. }
  1123.  
  1124. int TotalRegistroDB(char arq[256], char campo[256])
  1125. {
  1126.   /*
  1127.   Este comando verifica o total de campos iguais do arquivo, Tambem
  1128.   usado para verificar se um determinado campo existe no arquivo,
  1129.   so testar se o retorno eh maior que 0.
  1130.  
  1131.   Versao  : 1.0
  1132.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1133.   Entrada : Path+Nome Arquivo --> tmp:gallas.txt (CHAR 256)
  1134.             Campo do Registro --> path (CHAR 256)
  1135.   Saida   : Numero de Chaves iguais --> 1 (INT)
  1136.   Erro    : -1 Caso o arquivo de entrada nao exista, 0 Ok. (INT)
  1137.             TotalRegistroDB("tmp:gallas.txt", "path");
  1138.   */
  1139.  
  1140.   char teste[256], a;
  1141.   int x, total;
  1142.   FILE *entrada;
  1143.   if(!(entrada = fopen(arq, "r")))
  1144.     return -1;
  1145.   x = 0; total = 0;
  1146.   while(a = getc(entrada), ! feof(entrada))
  1147.   {
  1148.     teste[x++] = a;
  1149.     if(a == '\n')
  1150.     {
  1151.       teste[--x] = '\0';
  1152.       if(!(strcmp(Copia(Corta(teste, ':', 0), 4, 15), campo)))
  1153.         total++;
  1154.       teste[0] = '\0'; x = 0;
  1155.     }
  1156.   }
  1157.   fclose(entrada);
  1158.   return total;
  1159. }
  1160.  
  1161. int DeletaRegistroDB(char arq[256], char campo[256], char tmp[256])
  1162. {
  1163.   /*
  1164.   Este comando deleta um determinado campo do arquivo DB, caso
  1165.   exista mais de um campo igual, todos serao deletados.
  1166.  
  1167.   Versao  : 1.0
  1168.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1169.   Entradas : Path+Nome Arquivo  --> dh2:gallas.txt (CHAR 256)
  1170.              Campo a deletar    --> path (CHAR 256)
  1171.              Arquivo temporario --> ram:surround.tmp (CHAR 256)
  1172.   Saida    : O total de campos deletados --> 1 (INT)
  1173.   Erro     : -1 caso de problema na abertura do arquivo DB ou
  1174.              problema ao criar o arquivo temporario. > 0 Ok.
  1175.   Obs      : Caso o arquivo temporario seja pequeno, e nao muito
  1176.              variavel, jogue ele na RAM: assim sera bem mais rapido.
  1177.   DeletaRegistroDB("dh2:gallas.txt", "path", "ram:surround.tmp");
  1178.   */
  1179.  
  1180.   char teste[256], a;
  1181.   int x, total;
  1182.   FILE *entrada, *saida;
  1183.   if(!(entrada = fopen(arq, "r")))
  1184.     return -1;
  1185.   if(!(saida = fopen(tmp, "w")))
  1186.     return -1;
  1187.   x = 0; total = 0;
  1188.   while(a = getc(entrada), ! feof(entrada))
  1189.   {
  1190.     teste[x++] = a;
  1191.     if(a == '\n')
  1192.     {
  1193.       teste[--x] = '\0';
  1194.       if(!(strcmp(Copia(Corta(teste, ':', 0), 4, 15), campo)))
  1195.         total++;
  1196.       else
  1197.         fprintf(saida, "%s\n", teste);
  1198.       teste[0] = '\0'; x = 0;
  1199.     }
  1200.   }
  1201.   fclose(saida);
  1202.   fclose(entrada);
  1203.   CopiaArquivo(tmp, arq);
  1204.   remove(tmp);
  1205.   return total;
  1206. }
  1207.  
  1208. char *LeRegistroDB(char arq[256], char campo[256])
  1209. {
  1210.   /*
  1211.   Este comando le um determinado registro pela seu campo. Se o campo
  1212.   nao existir no arquivo o retorno sera nulo "". Se existir mais
  1213.   de um campo igual, sera retornado a primeiro.
  1214.  
  1215.   Versao  : 1.0
  1216.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1217.   Entrada : Path+Nome Arquivo  --> dh2:gallas.db (CHAR 256)
  1218.             Campo a ler        --> path (CHAR 256)
  1219.   Saida   : A linha da Chave 2 --> Campo da Chave 2 (CHAR 256)
  1220.             LeRegistroDB("dh2:gallas.db", "path");
  1221.   */
  1222.  
  1223.   char teste[256], a;
  1224.   int x;
  1225.   FILE *entrada;
  1226.   if(!(entrada = fopen(arq, "r")))
  1227.     return "";
  1228.   x = 0;
  1229.   while(a = getc(entrada), ! feof(entrada))
  1230.   {
  1231.     teste[x++] = a;
  1232.     if(a == '\n')
  1233.     {
  1234.       teste[--x] = '\0';
  1235.       if(!(strcmp(Corta(Corta(teste, ':', 0), '>', 1), campo))) {
  1236.         fclose(entrada);
  1237.       return AposCaracter(teste, ':', 1); }
  1238.       teste[0] = '\0'; x = 0;
  1239.     }
  1240.   }
  1241.   fclose(entrada);
  1242.   return "";
  1243. }
  1244.  
  1245. char *StringAscii(char key[256], int numero)
  1246. {
  1247.   /*
  1248.   Este comando recebe uma determinada String e retorna ela em
  1249.   codigos da tabela ASCII. Podendo ainda somar cada caracter ascii
  1250.   com um determinado numero.
  1251.  
  1252.   Versao  : 1.0
  1253.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1254.   Entrada : String a converter --> Gallas (CHAR 256)
  1255.             Numero a somar     --> 2
  1256.   Saida   : String em ASCII    --> 073099110110099117 (CHAR 256)
  1257.   Obs     : O Numero chave a ser passado nao deve exceder a 740,
  1258.             caso isso aconteca sera calculado como 1. Esta rotina
  1259.             foi feita para ajudar na criptografia de dados.
  1260.             StringAscii("Gallas", 2);
  1261.   */
  1262.  
  1263.   char cha[5], chat[5], chave[256];
  1264.   int x = 0;
  1265.   if(numero > 740)
  1266.     numero = 1;
  1267.     chave[0] = '\0';
  1268.   for(x = 0; x < strlen(key); x++)
  1269.   {
  1270.     sprintf(chat, "%u", key[x]);
  1271.     sprintf(cha, "%d", atoi(chat) + numero);
  1272.     if(strlen(cha) == 1)
  1273.       sprintf(chave, "%s00%s", chave, cha);
  1274.     if(strlen(cha) == 2)
  1275.       sprintf(chave, "%s0%s", chave, cha);
  1276.     if(strlen(cha) == 3)
  1277.       sprintf(chave, "%s%s", chave, cha);
  1278.   }
  1279.   return chave;
  1280. }
  1281.  
  1282. char *AsciiString(char key[256], int numero)
  1283. {
  1284.   /*
  1285.   Este comando recebe a string convertida para ascii e retorna
  1286.   ela para a sua string de origem baseado no numero chave que deve
  1287.   ser o mesmo.  
  1288.  
  1289.   Versao  : 1.0
  1290.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1291.   Entrada : Ascii a retornar    --> 073099110110099117 (CHAR 256)
  1292.             Numero a chave      --> 2
  1293.   Saida   : String de retorno   --> Gallas (CHAR 256)
  1294.             AsciiString("073099110110099117", 2);
  1295.   */
  1296.  
  1297.   char chave[256], saida[256], teste[256];
  1298.   int x = 0, contador = 0, y = 0;
  1299.  
  1300.   teste[0] = '\0';
  1301.   for(x = 0; x < strlen(key); x++)
  1302.   {
  1303.     chave[y++] = key[x]; contador++;
  1304.     if(contador == 3)
  1305.     {
  1306.       chave[y] = '\0';
  1307.             sprintf(saida, "%s%c", teste, (atoi(chave) - numero));
  1308.       strcpy(teste, saida);
  1309.       chave[0] = '\0'; y = 0; contador = 0;
  1310.     }
  1311.   }
  1312.   return saida;
  1313. }
  1314.  
  1315. char *CriptografiaSimples(char var[256], int opcao)
  1316. {
  1317.   /*
  1318.   Este comando criptografa e descriptografa uma determinada String.
  1319.  
  1320.   Versao  : 1.0
  1321.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1322.   Entrada : String --> Cristian (CHAR 256)
  1323.             Opcao  --> 0 (INT)
  1324.   Obs     : 0 Criptografa, 1 Descriptografa
  1325.   Saida   : String Alterada --> 2$#5%5mO (CHAR 256)
  1326.             CriptografiaSimples("Cristian", 0);
  1327.   */
  1328.  
  1329.   char teste[256], tabela1[256], tabela2[256];
  1330.   int x, posicao;
  1331.   if(opcao < 0 && opcao > 1)
  1332.     opcao = 0;
  1333.   strcpy(tabela1, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890~`!@#$%^&*()-_+=|\\{}[]:;'<>,./?\" öóòôõáàâãúùûéèêëíìîï®ç");
  1334.   strcpy(tabela2, " ~`!@#$%^&*()-_+=|\\{}[]:;'<>,./?\"1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzòôõáàâãúùûéèêëíìîïöóç®");
  1335.     teste[0] = '\0';
  1336.   posicao = 0;
  1337.   for(x = 0; x < strlen(var); x++)
  1338.   {
  1339.     if(opcao == 0) {
  1340.       posicao = PosicaoCaracter(tabela1, var[x], 1);
  1341.       sprintf(teste, "%s%c", teste, tabela2[--posicao]);
  1342.     } else {
  1343.       posicao = PosicaoCaracter(tabela2, var[x], 1);
  1344.       sprintf(teste, "%s%c", teste, tabela1[--posicao]);
  1345.     }
  1346.   }
  1347.   return teste;
  1348. }
  1349.  
  1350. char *TrimSur(char var[256], int opcao) 
  1351. {
  1352.   /*
  1353.   Este comando retira espacos dos cantos de uma string.
  1354.  
  1355.   Versao  : 1.0
  1356.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1357.   Entrada : String --> "     Cristian Robert Gallas     " (CHAR 256)
  1358.             Opcao  --> 0 (INT)
  1359.   Obs     : 0 Retira da esquerda e direita
  1360.             1 da direita
  1361.             2 da esquerda
  1362.   Saida   : String --> "Cristian Robert Gallas" (CHAR 256)
  1363.   Obs     : as aspas sao somente para demonstrar o efeito.
  1364.             TrimSur("     Cristian Robert Gallas     ", 0);
  1365.   */
  1366.  
  1367.   int x = 0;
  1368.   if(opcao < 0 && opcao > 2)
  1369.     opcao = 0;
  1370.   if(opcao == 1 || opcao == 0)
  1371.   {
  1372.     for(x = 0; x < strlen(var); x++)
  1373.       if(var[x] != ' ')
  1374.         break;
  1375.     strcpy(var, Copia(var, ++x, 256));
  1376.   }
  1377.   if(opcao == 2 || opcao == 0)
  1378.   {
  1379.     for(x = (strlen(var) - 1); x > 1; x--)
  1380.       if(var[x] != ' ')
  1381.         break;
  1382.     strcpy(var, Copia(var, 1, ++x));
  1383.   }
  1384.   return var;
  1385. }
  1386.  
  1387. char *DiaSemana(char var[20], int opcao) 
  1388. {
  1389.   /*
  1390.   Este comando recebe uma data e retorna o dia da semana.
  1391.  
  1392.   Versao  : 1.0
  1393.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1394.   Entrada : Data  --> 01.02.1997 (CHAR 20)
  1395.             Opcao --> 0 (INT)
  1396.   Obs     : 0 retorna em portugues
  1397.             1 ingles
  1398.             2 o numero do dia, inicio em 1 -> domingo.
  1399.   Saida   : Dia da Semana -> Segunda (CHAR RETURN)
  1400.             DiaSemana("01.02.1997", 0);
  1401.   */
  1402.  
  1403.   char teste[256];
  1404.   int x = 0;
  1405.   x = fmod(atof(Arredondar(DiaJuliano(var))), 7.0);
  1406.   if(opcao == 2)
  1407.   {
  1408.     sprintf(teste, "%d", x);
  1409.     return teste;
  1410.   }
  1411.   switch(x)
  1412.   {
  1413.     case 1: if(opcao == 0) return "Domingo"; else return "Sunday";
  1414.     case 2: if(opcao == 0) return "Segunda"; else return "Monday";
  1415.     case 3: if(opcao == 0) return "Terca"; else return "Tuesday";
  1416.     case 4: if(opcao == 0) return "Quarta"; else return "Wednesday";
  1417.     case 5: if(opcao == 0) return "Quinta"; else return "Thursday";
  1418.     case 6: if(opcao == 0) return "Sexta"; else return "Friday";
  1419.     case 0: if(opcao == 0) return "Sabado"; else return "Saturday";
  1420.   }
  1421.   return "ERRO";
  1422. }
  1423.  
  1424. char *EspacoString(char var[256], int tamanho, int opcao)
  1425. {
  1426.   /*
  1427.   Este comando acrescenta espacos na frente ou atras de uma string.
  1428.  
  1429.   Versao  : 1.0
  1430.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1431.   Entrada : String           --> "Cristian" (CHAR 256)
  1432.             Tamanho do campo --> 20 (INT)
  1433.             Opcao            --> 0 (INT)
  1434.   Obs     : 0 - Esquerda
  1435.             1 - Direita
  1436.   Saida   : String com espacos --> "            Cristian" (CHAR 256)
  1437.   Obs     : As aspas sao so para demonstrar o resultado.
  1438.             Caso o tamanho especificado do campo final for menor que o
  1439.             tamanho da string, o resultado sera cortado.
  1440.             EspacoString("Cristian", 20, 0);
  1441.   */
  1442.  
  1443.   char saida[256], teste[256];
  1444.   int x, y;
  1445.   x = strlen(var);
  1446.   y = tamanho - x;
  1447.   if(y <= 0)
  1448.     return Copia(var, 1, tamanho);
  1449.   for(x = 0; x < y; x++)
  1450.     teste[x] = ' ';
  1451.   teste[x] = '\0';
  1452.   if(opcao == 0)
  1453.     sprintf(saida, "%s%s", teste, var);
  1454.   else
  1455.     sprintf(saida, "%s%s", var, teste);
  1456.   return saida;
  1457. }
  1458.  
  1459. char *UltimaLinha(char var[256])
  1460. {
  1461.   /*
  1462.   Este comando pega a ultima linha de um arquivo. Rotina super
  1463.   rapida, usa posicionamento de arquivo.
  1464.  
  1465.   Versao  : 1.0
  1466.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1467.   Entrada : Path+Nome Arquivo --> dh2:gallas.txt (CHAR 256)
  1468.   Saida   : Ultima linha      --> Last Line (CHAR 256)
  1469.   Erro    : "ERRO" (CHAR RETURN)
  1470.             UltimaLinha("dh2:gallas.txt");
  1471.   */
  1472.  
  1473.   char a, teste[256];
  1474.   int x = 0, y = 0;
  1475.   FILE *entrada;
  1476.   if(!(entrada = fopen(var, "r")))
  1477.     return "ERRO";
  1478.   while(a = getc(entrada), ! feof(entrada))
  1479.   {
  1480.     teste[x++] = a;
  1481.     if(a == '\n')
  1482.     {
  1483.       y++; teste[--x] = '\0';
  1484.       if(y > 1)
  1485.         break;
  1486.     }
  1487.   }
  1488.   if(y == 1)
  1489.   {
  1490.     fclose(entrada);
  1491.     return teste;
  1492.   }
  1493.   fseek(entrada, 0, SEEK_END);
  1494.   while(a = getc(entrada), a != '\n' && a != '\0')
  1495.     fseek(entrada, -2, 1);
  1496.   x = 0; teste[0] = '\0';
  1497.   while(a = getc(entrada), ! feof(entrada))
  1498.     teste[x++] = a;
  1499.   teste[--x] = '\0';
  1500.   fclose(entrada);
  1501.   return teste;
  1502. }
  1503.  
  1504. char *UpperCase(char var[256]) 
  1505. {
  1506.   /*
  1507.   Este comando converte uma string para todos os caracteres em
  1508.   maiusculo.
  1509.  
  1510.   Versao  : 1.0
  1511.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1512.   Entrada : String a converter --> Cristian Gallas (CHAR 256)
  1513.   Saida   : String maiuscula   --> CRISTIAN GALLAS (CHAR 256)
  1514.             UpperCase("Cristian Gallas");
  1515.   */
  1516.  
  1517.   char teste[256];
  1518.   int x = 0, y = 0;
  1519.   for(x = 0; x < strlen(var); x++)
  1520.     teste[y++] = toupper(var[x]);
  1521.   teste[y] = '\0';
  1522.   return teste;
  1523. }
  1524.  
  1525. char *LowerCase(char var[256]) 
  1526. {
  1527.   /*
  1528.   Este comando converte uma string para todos os caracteres em
  1529.   minusculo.
  1530.  
  1531.   Versao  : 1.0
  1532.   Entrada : String a converter --> CRISTIAN GALLAS (CHAR 256)
  1533.   Saida   : String maiuscula   --> cristian gallas (CHAR 256)
  1534.             LowerCase("CRISTIAN GALLAS");
  1535.   */
  1536.  
  1537.   char teste[256];
  1538.   int x = 0, y = 0;
  1539.   for(x = 0; x < strlen(var); x++)
  1540.     teste[y++] = tolower(var[x]);
  1541.   teste[y] = '\0';
  1542.   return teste;
  1543. }
  1544.  
  1545. char *PrimeiroUpper(char var[256]) 
  1546. {
  1547.   /*
  1548.   Este comando converto todos os primeiros caracteres das palavras
  1549.   de uma determinada frase ou string para maiusculo.
  1550.  
  1551.   Versao  : 1.0
  1552.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1553.   Entrada : String a converter --> cristian gallas (CHAR 256)
  1554.   Saida   : String convertida  --> Cristian Gallas (CHAR 256)
  1555.             PrimeiroUpper("cristian gallas");
  1556.   */
  1557.  
  1558.   char teste[256];
  1559.   int x = 0, y = 0, ativa = 0;
  1560.   for(x = 0; x < strlen(var); x++)
  1561.   {
  1562.     if(x == 0 || var[x - 1] == ' ')
  1563.       ativa = 1;
  1564.     if(ativa == 0)
  1565.       teste[y++] = tolower(var[x]);
  1566.     else
  1567.     {
  1568.       ativa = 0;
  1569.       teste[y++] = toupper(var[x]);
  1570.     }
  1571.   }
  1572.   teste[y] = '\0';
  1573.   return teste;
  1574. }
  1575.  
  1576. char *StringParaCgc(char var[30])
  1577. {
  1578.   /*
  1579.   Este comando recebe um numero de 14 algarismos e retorna formatado
  1580.   no formato padrao de CGC.
  1581.  
  1582.   Versao  : 1.0
  1583.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1584.   Entrada : Numero --> 12345678901234 (CHAR 30)
  1585.   Saida   : Cgc    --> 12.345.678/9012-34 (CHAR 30)
  1586.   Erro    : ERRO (CHAR RETURN) Quando passado diferente de 14 algarismos
  1587.             StringParaCgc("12345678901234");
  1588.   */
  1589.  
  1590.   char x1[6], x2[6], x3[6], x4[6], x5[6], teste[256];
  1591.   if(strlen(var) != 14)
  1592.     return "ERRO";
  1593.   strcpy(x1, Copia2(var, 1, 2));
  1594.   strcpy(x2, Copia2(var, 3, 3));
  1595.   strcpy(x3, Copia2(var, 6, 3));
  1596.   strcpy(x4, Copia2(var, 9, 4));
  1597.   strcpy(x5, Copia2(var, 13, 2));
  1598.   sprintf(teste, "%s.%s.%s/%s-%s", x1, x2, x3, x4, x5);
  1599.   return teste;
  1600. }
  1601.  
  1602. int ExisteDiretorio(char var[256]) 
  1603. {
  1604.   /*
  1605.   Rotina que testa se um diretorio existe.  
  1606.  
  1607.   Versao  : 1.0
  1608.   Compila : AmigaDos
  1609.   Entrada : Path --> dh2:tmp/ (CHAR 256)
  1610.   Saida   : True (-1) se existir e False (0) se nao existir (INT)
  1611.             if(ExisteDiretorio("dh2:tmp/"))
  1612.   */
  1613.  
  1614.   DIR *dfd;
  1615.  
  1616.   if(!(dfd = opendir(var))) {
  1617.     closedir(dfd);
  1618.     return 0;
  1619.   } else {
  1620.     closedir(dfd);
  1621.     return -1; }
  1622. }
  1623.  
  1624. int FinalArquivo(char var[256], char var2[256], int numero)
  1625. {
  1626.   /*
  1627.   Este comando pega determinadas linhas do final do arquivo
  1628.   e gera outro arquivo com seu conteudo.
  1629.  
  1630.   Versao  : 1.0
  1631.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1632.   Entrada : Path+Nome Arquivo Entrada --> dh2:gallas.txt (CHAR 256)
  1633.             Path+Nome Arquivo Saida   --> dh2:saida.txt  (CHAR 256)
  1634.             Numero de linhas          --> 10
  1635.   Saida   : Sera pego as ultimas 10 linhas do arquivo de entrada
  1636.             e gravado no arquivo de saida.
  1637.             Retorna [-1] se sucesso e [0] se erro.
  1638.             FinalArquivo("dh2:gallas.txt", "dh2:saida.txt", 10);
  1639.   */
  1640.  
  1641.   char a, teste[256];
  1642.   int x = 0, total = 0;
  1643.   FILE *entrada, *saida;
  1644.   total = LinhasArquivo(var);
  1645.   if(total <= numero)
  1646.     {
  1647.     CopiaArquivo(var, var2);
  1648.         return -1;
  1649.   }
  1650.   if(!(entrada = fopen(var, "r")))
  1651.     return 0;
  1652.   if(!(saida = fopen(var2, "w")))
  1653.     return 0;
  1654.   /* Posiciona e pega as linhas requisitadas do final */
  1655.   fseek(entrada, 0, SEEK_END);
  1656.   while(a = getc(entrada), x < numero) {
  1657.     if(a == '\n')
  1658.             x++;
  1659.     fseek(entrada, -2, 1); }
  1660.   x = 0; teste[0] = '\0'; getc(entrada);
  1661.   while(a = getc(entrada), ! feof(entrada))
  1662.     fprintf(saida, "%c", a);
  1663.   fclose(entrada);
  1664.   fclose(saida);
  1665.   return -1;
  1666. }
  1667.  
  1668. char *FiltraCaracter(char var[256], int opcao) 
  1669. {
  1670.   /* 
  1671.   Este comando filtra uma string seguindo as seguintes opcoes.
  1672.  
  1673.   Versao  : 1.0
  1674.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1675.     Entrada : String a filtrar --> 051-632-28-05
  1676.             Opcao            --> 0
  1677.   Obs:    : Opcoes de tipo de filtro
  1678.             0 -> Filtra e retorna somente numeros
  1679.             1 -> Filtra e retorna somente letras
  1680.             2 -> Filtra e retorna somente letras e numeros
  1681.   Saida   : String Filtrada  --> 0516322805
  1682.             FiltraCaracter("051-632-28-05", 0);
  1683.   */
  1684.  
  1685.   char teste[256];
  1686.   int x = 0, y = 0;
  1687.   if(opcao < 0 || opcao > 2)
  1688.     opcao = 2;
  1689.   for(x = 0; x < strlen(var); x++)
  1690.   {
  1691.     if(opcao == 0)
  1692.             if(isdigit(var[x]))
  1693.                 teste[y++] = var[x];
  1694.     if(opcao == 1)
  1695.             if(isalpha(var[x]))
  1696.                 teste[y++] = var[x];
  1697.     if(opcao == 2)
  1698.             if(isalnum(var[x]))
  1699.                 teste[y++] = var[x];
  1700.   }
  1701.   teste[y] = '\0';
  1702.   return teste;
  1703. }
  1704.  
  1705. char *InsereString(char var[256], char var2[256], int numero)
  1706. {
  1707.   /*
  1708.   Esta rotina acrescenta uma string dentro de outra, adicionando
  1709.   na posicao passada como parametro.
  1710.  
  1711.   Versao  : 1.0
  1712.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1713.   Entrada : String Inicial      --> CristianGallas (CHAR 256)
  1714.             String a Adicionar  --> Robert (CHAR 256)
  1715.             Posicao a Adicionar --> 9 (INT)
  1716.   Saida   : Juncao das duas     --> CristianRobertGallas (CHAR 256)
  1717.             InsereString("CristianGallas", "Robert", 9);
  1718.   Obs     : O caracter inicia em 1!
  1719.   */
  1720.  
  1721.     char parte1[256], parte2[256], teste[256];
  1722.   numero--;
  1723.   strcpy(parte1, Copia(var, 1, numero));
  1724.   strcpy(parte2, Copia(var, numero+1, 256));
  1725.     sprintf(teste, "%s%s%s", parte1, var2, parte2);
  1726.     return teste;
  1727. }
  1728.  
  1729. char *Online(char dat[256], char hora[256], char tempo[256])
  1730. {
  1731.   /*
  1732.   Esta rotina retorna os dados referentes a uma coneccao 
  1733.   calculando a hora de desconeccao e o dia.
  1734.  
  1735.   Versao  : 1.0
  1736.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1737.   Entrada : Dia da coneccao  --> 01.01.1997 (CHAR 256)
  1738.             Hora da coneccao --> 23:10:10 (CHAR 256)
  1739.             Tempo online     --> 01:20:02 (CHAR 256)
  1740.   Saida   : A saida sao 5 campos separados pelo caracter @
  1741.             Ex: 729398@729398@8341@1812@4802@10153
  1742.             Campo 1 --> Data de coneccao (Juliano)
  1743.             Campo 2 --> Data de desconeccao (Juliano)
  1744.             Campo 3 --> Hora de coneccao (Segundos)
  1745.             Campo 4 --> Hora de desconeccao (Segundos)
  1746.             Campo 5 --> Tempo de coneccao (Segundos)
  1747.             Campo 6 --> Hora Direta +24 (Segundos)
  1748.             Online("01.01.1997", "23:10:10", "01:20:02");
  1749.   */
  1750.  
  1751.   char teste[256];
  1752.   float dia1, dia2;
  1753.   int hora1, hora2, tempoon, horadireta;
  1754.   dia1 = atof(DiaJuliano(dat));
  1755.   hora1 = atoi(HoraSegundo(hora));
  1756.   hora2 = hora1 + atoi(HoraSegundo(tempo));
  1757.   tempoon = atoi(HoraSegundo(tempo));
  1758.   sprintf(teste, "%d", hora2);
  1759.   strcpy(teste, Corta(SegundoHora(teste), ':', 0));
  1760.   dia2 = dia1 + (atoi(teste) / 24);
  1761.   horadireta = hora2;
  1762.   if(atoi(teste) > 23)
  1763.     hora2 = hora2 - 86400; 
  1764.   sprintf(teste, "%f@%f@%d@%d@%d@%d", dia1, dia2, hora1, hora2, tempoon, horadireta);
  1765.   return teste;
  1766. }
  1767.  
  1768. int GravaLinha(char var[256], char linha[256], char comando[10])
  1769. {
  1770.   /* 
  1771.   Este comando adiciona uma linha em um determinado arquivo.
  1772.  
  1773.   Versao  : 1.0
  1774.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1775.   Entrada : Path+Nome Arquivo --> dh2:gallas.txt
  1776.             A Linha a adicionar --> Gallas
  1777.             O tipo de comando   --> a, w
  1778.   Saida   : Caso de erro retornado -1 se ok, retorna 0.
  1779.   Obs     : a Adiciona no arquivo, w inicializa arquivo com a linha.
  1780.             GravaLinha("dh2:gallas.txt", "Gallas", "a");
  1781.   */
  1782.  
  1783.   FILE *saida;
  1784.   if(!(saida = fopen(var, comando)))
  1785.     return -1;
  1786.   fprintf(saida, "%s", linha);
  1787.   fclose(saida);
  1788.   return 0;
  1789. }
  1790.  
  1791. int InsereArquivo(char var1[256], char var2[256])
  1792. {
  1793.   /*
  1794.   Este comando insere um arquivo em outro.
  1795.  
  1796.   Versao  : 1.0
  1797.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1798.   Entrada : Path+Nome arquivo origem  --> dh2:gallas.txt (CHAR 256)
  1799.             Path+Nome arquivo destino --> dh2:gallas.tmp (CHAR 256)
  1800.   Saida   : -1 Erro abertura na origem ou criacao destino, 0 OK (INT)
  1801.             InsereArquivo("dh2:gallas.txt", "dh2:gallas.tmp");
  1802.   */
  1803.  
  1804.   char a;
  1805.   FILE *entrada, *saida;
  1806.   if(!(entrada = fopen(var1, "r")))
  1807.     return -1;
  1808.   if(!(saida = fopen(var2, "a")))
  1809.     return -1;
  1810.   while(a = getc(entrada), ! feof(entrada))
  1811.     fputc(a, saida);
  1812.   fclose(entrada);
  1813.   fclose(saida);
  1814.   return 0;
  1815. }
  1816.  
  1817. char *JulianoDia(char var[256])
  1818. {
  1819.   /* Esta rotina converte dia juliano para data.
  1820.  
  1821.   Versao  : 1.0
  1822.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1823.   Entrada : Dia Juliano         --> 729040 (CHAR 256)
  1824.   Saida   : Data Correspondente --> 01.01.1997 (CHAR 256)
  1825.             JulianoDia("729040");
  1826.   */
  1827.  
  1828.   char teste[256];
  1829.     float pdatajul = 0, x = 0;
  1830.   int y = 0, ano = 0, mes = 1, dia = 0;
  1831.   pdatajul = atof(var);
  1832.   ano = (((pdatajul - 1) - ((pdatajul - 1) / 1461)) / 365) + 1;
  1833.   x = ano;
  1834.   y = fmod(x, 4.0);
  1835.   if(y != 0)
  1836.   {
  1837.     y = (pdatajul - 1) / 1461;
  1838.     x = ((pdatajul - 1) - y);
  1839.     dia = fmod(x, 365.0) + 1;
  1840.     if((dia > 31) && (dia <= 59))
  1841.     {
  1842.       mes = 2;
  1843.       dia = dia - 31;
  1844.     }
  1845.     if((dia > 59) && (dia <= 90))
  1846.     {
  1847.       mes = 3;
  1848.       dia = dia - 59;
  1849.     }
  1850.     if((dia > 90) && (dia <= 120))
  1851.     {
  1852.       mes = 4;
  1853.       dia = dia - 90;
  1854.     }
  1855.     if((dia > 120) && (dia <= 151))
  1856.     {
  1857.       mes = 5;
  1858.       dia = dia - 120;
  1859.     }
  1860.     if((dia > 151) && (dia <= 181))
  1861.     {
  1862.       mes = 6;
  1863.       dia = dia - 151;
  1864.     }
  1865.     if((dia > 181) && (dia <= 212))
  1866.     {
  1867.       mes = 7;
  1868.       dia = dia - 181;
  1869.     }
  1870.     if((dia > 212) && (dia <= 243))
  1871.     {
  1872.       mes = 8;
  1873.       dia = dia - 212;
  1874.     }
  1875.     if((dia > 243) && (dia <= 273))
  1876.     {
  1877.       mes = 9;
  1878.       dia = dia - 243;
  1879.     }
  1880.     if((dia > 273) && (dia <= 304))
  1881.     {
  1882.       mes = 10;
  1883.       dia = dia - 273;
  1884.     }
  1885.     if((dia > 304) && (dia <= 334))
  1886.     {
  1887.       mes = 11;
  1888.       dia = dia - 304;
  1889.     }
  1890.     if(dia > 334)
  1891.     {
  1892.       mes = 12;
  1893.       dia = dia - 334;
  1894.     }
  1895.   }
  1896.   else
  1897.   {
  1898.     y = fmod(pdatajul, 1461.0);
  1899.     if(y != 0)
  1900.     {
  1901.       y = (pdatajul - 1) / 1461;
  1902.             x = pdatajul - 1;
  1903.             dia = (fmod((x - y), 365.0)) + 1;
  1904.     }
  1905.     else
  1906.       dia = 366;
  1907.     
  1908.     if((dia > 31) && (dia <= 60))
  1909.     {
  1910.       mes = 2;
  1911.       dia = dia - 31;
  1912.     }
  1913.     if((dia > 60) && (dia <= 91))
  1914.     {
  1915.       mes = 3;
  1916.       dia = dia - 60;
  1917.     }
  1918.     if((dia > 91) && (dia <= 121))
  1919.     {
  1920.       mes = 4;
  1921.       dia = dia - 91;
  1922.     }
  1923.     if((dia > 121) && (dia <= 152))
  1924.     {
  1925.       mes = 5;
  1926.       dia = dia - 121;
  1927.     }
  1928.     if((dia > 152) && (dia <= 182))
  1929.     {
  1930.       mes = 6;
  1931.       dia = dia - 152;
  1932.     }
  1933.     if((dia > 182) && (dia <= 213))
  1934.     {
  1935.       mes = 7;
  1936.       dia = dia - 182;
  1937.     }
  1938.     if((dia > 213) && (dia <= 244))
  1939.     {
  1940.       mes = 8;
  1941.       dia = dia - 213;
  1942.     }
  1943.     if((dia > 244) && (dia <= 274))
  1944.     {
  1945.       mes = 9;
  1946.       dia = dia - 244;
  1947.     }
  1948.     if((dia > 274) && (dia <= 305))
  1949.     {
  1950.       mes = 10;
  1951.       dia = dia - 274;
  1952.     }
  1953.     if((dia > 305) && (dia <= 335))
  1954.     {
  1955.       mes = 11;
  1956.       dia = dia - 305;
  1957.     }
  1958.     if(dia > 335)
  1959.     {
  1960.       mes = 12;
  1961.       dia = dia - 335;
  1962.     }
  1963.   }
  1964.     sprintf(teste, "%d.%d.%d", dia, mes, ano);
  1965.   strcpy(teste, ArrumaDataHora(teste, '.'));
  1966.     return teste;
  1967. }
  1968.  
  1969. char *SomaDiminuiMes(char data[256], int nmes)
  1970. {
  1971.   /* 
  1972.   Esta rotina soma ou diminui um mes a uma determinada data,   
  1973.   testando e arrumando o ano, caso necessario.
  1974.  
  1975.   Versao  : 1.0
  1976.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1977.   Ex1:
  1978.   Entrada : Data             --> 10.01.1997 (CHAR 256)
  1979.             Meses a calcular --> 2 (INT)
  1980.   Saida   : Data com a soma de 2 meses --> 10.03.1997 (CHAR 256)
  1981.   Ex2:
  1982.   Entrada : Data             --> 10.01.1997 (CHAR 256)
  1983.             Meses a calcular --> -2 (INT)
  1984.   Saida   : Data com a soma de 2 meses --> 10.11.1996 (CHAR 256)
  1985.   Obs     : Essa rotina nao testa o dia.
  1986.             SomaDiminuiMes("10.01.1997", 2);
  1987.             SomaDiminuiMes("10.01.1997", -2);
  1988.   */
  1989.  
  1990.   char teste[256];
  1991.   int x, dia, mes, ano;
  1992.   dia = atoi(Corta(data, '.', 0));
  1993.   mes = atoi(Corta(data, '.', 1));
  1994.   ano = atoi(Corta(data, '.', 2));
  1995.   if(nmes > 0)
  1996.   {
  1997.     for(x = 0; x < nmes; x++) {
  1998.       mes++;
  1999.       if(mes == 13) {
  2000.     mes = 1;
  2001.     ano++; } }
  2002.   }
  2003.   else
  2004.   {
  2005.     for(x = 0; x < (nmes * -1); x++) {
  2006.       mes--;
  2007.       if(mes == 0) {
  2008.         mes = 12;
  2009.         ano--; } }
  2010.   }
  2011.   sprintf(teste, "%d.%d.%d", dia, mes, ano);
  2012.   strcpy(teste, ArrumaDataHora(teste, '.'));
  2013.   return teste;
  2014. }
  2015.  
  2016. char *IntervaloPeriodo(char periodo1[30], char periodo2[30], char periodo3[30], char periodo4[30], int xdias)
  2017. {
  2018.   /*
  2019.   Este comando verifica o periodo valido de um determinado periodo
  2020.   de tempo em relacao a outro.
  2021.  
  2022.   Versao  : 1.0
  2023.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2024.   Entrada : Periodo 1 (Fixo) --> 01:00:00 (CHAR 30)
  2025.             Periodo 2 (Fixo) --> 05:00:00 (CHAR 30)
  2026.             Periodo 3        --> 03:00:00 (CHAR 30)
  2027.             Periodo 4        --> 06:00:00 (CHAR 30)
  2028.             Dias intermediarios --> 1 (INT)
  2029.   Obs     : O pediodo 1 e 2 sao fixos, no caso nao contabilizam
  2030.             no horario de saida.
  2031.   Saida   : Periodo real usado --> 01:00:00 (CHAR 30)
  2032.             IntervaloPeriodo("01:00:00", "05:00:00", "03:00:00", "06:00:00", 1);
  2033.   */
  2034.  
  2035.   char teste[256];
  2036.   int r = 0, h1 = 0, h2 = 0, x1 = 0, x2 = 0, horas = 0;
  2037.  
  2038.   h1 = atoi(HoraSegundo(periodo1));
  2039.   h2 = atoi(HoraSegundo(periodo2));
  2040.   x1 = atoi(HoraSegundo(periodo3));
  2041.   x2 = atoi(HoraSegundo(periodo4));
  2042.  
  2043.   if(xdias == 0)
  2044.     xdias = 1;
  2045.   if((x2 < x1) || (h2 < h1))
  2046.   {
  2047.     x2 = x2 + (xdias * 86400);
  2048.     if((h1 < h2) && (h1 > 0))
  2049.             h1 = h1 + (xdias * 86400);
  2050.     h2 = h2 + (xdias * 86400);
  2051.   }
  2052.  
  2053.   horas = x2 - x1;
  2054.   if((x1 < h1) && (x2 > h2))
  2055.     horas = (h1 - x1) + (x2 - h2);
  2056.   else
  2057.   {
  2058.     if((x1 >= h1) && (x1 <= h2)) {
  2059.       if((x2 >= h1) && (x2 <= h2)) {
  2060.         r = x2 - x1;
  2061.       } else {
  2062.         r = h2 - x1; }
  2063.     } else
  2064.       if((x2 >= h1) && (x2 <= h2)) {
  2065.         r = x2 - h1;
  2066.       } else {
  2067.         r = 0; }
  2068.     horas = horas - r;
  2069.   }
  2070.   sprintf(teste, "%d", horas);
  2071.   return ArrumaDataHora(SegundoHora(teste), ':');
  2072. }
  2073.  
  2074. char *AlteraCampo(char var[256], char var2[256], char delimitador, int campo)
  2075. {
  2076.   /*
  2077.   Esta funcao altera um determinado campo dentro de uma string.
  2078.  
  2079.   Versao  : 1.0
  2080.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2081.   Entrada : String com os campos--> Cristian,Rbr,Gallas (CHAR 256)
  2082.             Campo novo          --> Robert (CHAR 256)
  2083.             Delimitador campos  --> , (CHAR 1)
  2084.             Campo (inicia em 0) --> 1 (INT)
  2085.   Saida   : Linha alterada      --> Cristian,Robert,Gallas (CHAR 256)
  2086.             AlteraCampo("Cristian,Rbr,Gallas", "Robert", ',', 1);
  2087.   */
  2088.  
  2089.   char teste[256], parte1[256], parte2[256];
  2090.   int posicao1 = 0,  posicao2 = 0;
  2091.   if(campo == 0)
  2092.     posicao1 = 0;
  2093.   else
  2094.     posicao1 = PosicaoCaracter(var, delimitador, campo);
  2095.   posicao2 = PosicaoCaracter(var, delimitador, campo+1);
  2096.   strcpy(parte1, Copia(var, 1, posicao1));
  2097.   strcpy(parte2, Copia(var, posicao2, 256));
  2098.   sprintf(teste, "%s%s%s", parte1, var2, parte2);
  2099.   return teste;
  2100. }
  2101.  
  2102. int DiretorioArquivo(char var[256], char arquivo[256], int opcao)
  2103. {
  2104.   /* 
  2105.   Este comando lista o conteudo de um determinado diretorio
  2106.   e gera um arquivo com o conteudo em si.
  2107.  
  2108.   Versao  : 1.0
  2109.   Compila : AmigaDos
  2110.     Entrada : Path a listar --> dh0:c/ (CHAR 256)
  2111.             Arquivo Saida --> ram:saida.tmp (CHAR 256)
  2112.             Opcao         --> 1 (INT)
  2113.           * Opcao 0, grava sem path absoluta, 1 grava com path.
  2114.   Saida   : Sera gerado o arquivo com o conteudo do diretorio,
  2115.             retorna um INT, -1 tudo ok, e 0 deu erro. (INT)
  2116.             DiretorioArquivo("dh0:c/", "ram:saida.tmp", 1);
  2117.   */
  2118.  
  2119.   char teste[256];
  2120.   DIR *dfd;
  2121.   FILE *saida;
  2122.   struct dirent *dptr;
  2123.   if(strcmp(Copia2(var, strlen(var), 1), ":") &&
  2124.      strcmp(Copia2(var, strlen(var), 1), "/"))
  2125.     sprintf(teste, "%s/", var);
  2126.   else 
  2127.     strcpy(teste, var);
  2128.     if(!ExisteDiretorio(teste))
  2129.     return 0;
  2130.   if(!(saida = fopen(arquivo, "w")))
  2131.     return 0;
  2132.   dfd = opendir(teste);
  2133.   while ((dptr = readdir(dfd)) != NULL)
  2134.     if(opcao == 0)
  2135.             fprintf(saida, "%s\n", dptr->d_name);
  2136.     else
  2137.             fprintf(saida, "%s%s\n", teste, dptr->d_name);
  2138.   closedir(dfd);
  2139.   fclose(saida);
  2140.   return -1;
  2141. }
  2142.  
  2143. int TestaData(char var[256])
  2144. {
  2145.   /*
  2146.   Esta rotina testa a validade de um determinado formato de 
  2147.   data.
  2148.  
  2149.   Versao  : 1.0
  2150.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2151.   Entrada : Data [DD.MM.AAAA] --> 01.01.1997 (CHAR 256)
  2152.   Saida   : 0 se data invalida e -1 se data certa. (INT)
  2153.   Obs     : O separador de data deve ser sempre o [.]  
  2154.             Os testes de validade consistem em:
  2155.             Dia >= 1 e Dia <=31, Mes >= 1 e Mes <= 12,
  2156.             Ano >= 1900, Tamanho do formato da data = 10
  2157.             if(TestaData("01.01.1997"))
  2158.   */
  2159.           
  2160.   int dia = 0, mes = 0, ano = 0;
  2161.   dia = atoi(Corta(var, '.', 0));
  2162.   mes = atoi(Corta(var, '.', 1));
  2163.   ano = atoi(Corta(var, '.', 2));
  2164.   if(((dia < 1) || (dia > 31)) ||
  2165.      ((mes < 1) || (mes > 12)) ||
  2166.      (ano < 1900) ||
  2167.      (strlen(var) != 10))
  2168.     return 0;
  2169.   return -1;
  2170. }
  2171.  
  2172. int TestaHora(char var[256])
  2173. {
  2174.   /*
  2175.   Este comando testa se um determinado horario eh valido.
  2176.  
  2177.   Versao  : 1.0
  2178.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2179.   Entrada : Hora completa [HH:MM:SS] --> 23:59:59 (CHAR 259)
  2180.   Saida   : 0 se a hora eh invalida e -1 se a hora eh certa. (INT)
  2181.   Obs     : O separador deve ser sempre o [:]
  2182.             Os testes de validade consistem sempre em:
  2183.             Hora > 0 e Hora < 24, Minutos > 0 e Minutos < 60,
  2184.             Segundos > 0 e Segundos < 60,
  2185.             Formado da Hora = 8
  2186.             if(TestaHora("23:59:59"))
  2187.   */         
  2188.  
  2189.   int hh = 0, mm = 0, ss = 0;
  2190.   hh = atoi(Corta(var, ':', 0));
  2191.   mm = atoi(Corta(var, ':', 1));
  2192.   ss = atoi(Corta(var, ':', 2));
  2193.   if(((hh < 0) || (hh > 23)) ||
  2194.      ((mm < 0) || (mm > 59)) ||
  2195.      ((ss < 0) || (ss > 59)) ||
  2196.      (strlen(var) != 8))
  2197.     return 0;
  2198.   return -1;
  2199. }
  2200.  
  2201. int UnirArquivos(char saida[256], char lista[256]) 
  2202. {
  2203.   /*
  2204.   Este comando uni arquivos apartir de uma lista.
  2205.  
  2206.   Versao  : 1.0
  2207.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2208.   Entrada : Path+Nome Arquivo Saida --> gallas.txt (CHAR 256)
  2209.             Path+Nome Arquivo Lista --> lista.txt (CHAR 256)
  2210.   Saida   : Sera gerado o arquivo de saida contendo todos os
  2211.             arquivos incluidos na lista. O comando retorna
  2212.             0 se ocorrer erro e -1 se sucesso. (INT)
  2213.   Obs     : A lista eh um arquivo texto, ex:
  2214.             Arquivo1.txt
  2215.             Arquivo2.txt
  2216.             Arquivo3.txt
  2217.             UnirArquivos("gallas.txt", "lista.txt");
  2218.   */
  2219.  
  2220.   char a, teste[256];
  2221.   int x = 0;
  2222.   FILE *entrada;
  2223.     if(!(entrada = fopen(lista, "r")))
  2224.     return 0;
  2225.      x = 0;
  2226.   while(a = getc(entrada), ! feof(entrada))
  2227.   {
  2228.         teste[x++] = a;
  2229.     if(a == '\n')
  2230.     {
  2231.       teste[--x] = '\0';
  2232.       InsereArquivo(teste, saida);   
  2233.       teste[0] = '\0'; x = 0;
  2234.     }
  2235.   } 
  2236.   fclose(entrada);
  2237.   return -1;
  2238. }
  2239.  
  2240. char *UltimoCaracter(char var[256])
  2241. {
  2242.   /*
  2243.   Este comando retorna o ultimo caracter de uma string.
  2244.  
  2245.   Versao  : 1.0
  2246.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2247.   Entrada : String --> Cristian (CHAR 256)
  2248.   Saida   : Ultimo --> n        (CHAR 256)
  2249.             UltimoCaracter("Cristian");
  2250.   */
  2251.  
  2252.   char teste[256];
  2253.   strcpy(teste, Copia2(var, strlen(var), 1));
  2254.   return teste;
  2255. }
  2256.  
  2257. char *FiltraDir(char var[256], int opcao)
  2258. {
  2259.   /*
  2260.   Este comando filtra um diretorio.
  2261.  
  2262.   Versao  : 1.0
  2263.   Entrada : Diretorio --> tmp:gallas (CHAR 256)
  2264.             Opcao     --> 1 (INT)
  2265.           * Opcao 0 sem barra no final, 1 com barra no final.
  2266.   Obs     : Device eh retornado igual, ex: work:
  2267.   Saida   : Diretorio Filtrado --> tmp:gallas/ (CHAR 256)
  2268.             FiltraDir("tmp:gallas", 1);
  2269.   */
  2270.   
  2271.   char teste[256];
  2272.   strcpy(teste, UltimoCaracter(var));
  2273.   if(!strcmp(teste, ":"))
  2274.     return var;
  2275.   if(!strcmp(teste, "/") && opcao == 0)
  2276.     return Copia(var, 1, (strlen(var) - 1));
  2277.   if(strcmp(teste, "/") && opcao == 1)
  2278.   {
  2279.     sprintf(teste, "%s/", var);
  2280.     return teste;
  2281.   }
  2282.   return var;
  2283. }
  2284.  
  2285. int DeletaArquivos(char lista[256]) 
  2286. {
  2287.   /*
  2288.   Este comando deleta arquivos apartir de uma lista.
  2289.  
  2290.   Versao  : 1.0
  2291.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2292.   Entrada : Path+Nome Arquivo Lista --> lista.txt (CHAR 256)
  2293.   Saida   : Sera deletado todos os arquivos contidos na lista,
  2294.             0 se ocorrer erro e -1 se sucesso. (INT)
  2295.   Obs     : A lista eh um arquivo texto, ex:
  2296.             Arquivo1.txt
  2297.             Arquivo2.txt
  2298.             Arquivo3.txt
  2299.             DeletaArquivos("lista.txt");
  2300.   */
  2301.  
  2302.   char a, teste[256];
  2303.   int x = 0;
  2304.   FILE *entrada;
  2305.     if(!(entrada = fopen(lista, "r")))
  2306.     return 0;
  2307.      x = 0;
  2308.   while(a = getc(entrada), ! feof(entrada))
  2309.   {
  2310.         teste[x++] = a;
  2311.     if(a == '\n')
  2312.     {
  2313.       teste[--x] = '\0';
  2314.       remove(teste);
  2315.       teste[0] = '\0'; x = 0;
  2316.     }
  2317.   } 
  2318.   fclose(entrada);
  2319.   return -1;
  2320. }
  2321.  
  2322. char *CasasAposCaracter(char var[256], char caracter, int casas)
  2323. {
  2324.   /* 
  2325.   Este comando recorta a string determinadas casas apos um 
  2326.   caracter, partindo do inicio, bom para cortar valores, 
  2327.   determinando numero de casas apos a virgula.
  2328.  
  2329.   Versao  : 1.0
  2330.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2331.   Entrada : String      --> 123,3456 (CHAR 256)
  2332.             Caracter    --> , (CHAR 1)
  2333.             Numero apos --> 2
  2334.   Saida   : String com duas casas apos virgula --> 123,34 (CHAR 256)
  2335.             CasasAposCaracter("123,3456", ',', 2);
  2336.   */
  2337.  
  2338.   char teste[256];
  2339.   int x = 0;
  2340.   x = PosicaoCaracter(var, caracter, 1);
  2341.   x = x + casas;
  2342.   strcpy(teste, Copia(var, 1, x));
  2343.   return teste;
  2344. }
  2345.  
  2346. char *ExaminaArquivo(char arq[256], int opcao)
  2347. {
  2348.   /* 
  2349.   Este comando retira informacoes sobre um determinado arquivo.
  2350.  
  2351.   Versao  : 1.0
  2352.   Compila : AmigaDos
  2353.   Entrada : Path+Nome Arquivo --> dh2:texto.txt (CHAR 256)
  2354.             Opcao             --> 0 (INT)
  2355.   Obs     : 0 --> Tamanho em bytes do arquivo
  2356.             1 --> DiskKey
  2357.             2 --> Se eh arquivo ou diretorio, < 0 arquivo, > 0 diretorio
  2358.             3 --> Nome do arquivo
  2359.             4 --> Protecao do arquivo
  2360.             5 --> Numero de blocos do arquivo
  2361.             6 --> Comentario do arquivo
  2362.   Saida   : Qtd de caracteres --> 2434 (INT)
  2363.             ExaminaArquivo("dh2:texto.txt", 0);
  2364.   */
  2365.  
  2366.   char teste[256];
  2367.   BPTR lock;
  2368.   struct FileInfoBlock __aligned fib;
  2369.   if(!(lock = Lock(arq, SHARED_LOCK)))
  2370.     return 0;
  2371.   if(!Examine(lock, &fib)) {
  2372.     UnLock(lock);
  2373.     return 0; }
  2374.   UnLock(lock);
  2375.   switch(opcao)
  2376.   {
  2377.     case 0: sprintf(teste, "%d", fib.fib_Size); break;
  2378.     case 1: sprintf(teste, "%d", fib.fib_DiskKey); break;
  2379.     case 2: sprintf(teste, "%d", fib.fib_DirEntryType); break;
  2380.     case 3: sprintf(teste, "%s", fib.fib_FileName); break;
  2381.     case 4: sprintf(teste, "%d", fib.fib_Protection); break;
  2382.     case 5: sprintf(teste, "%d", fib.fib_NumBlocks); break;
  2383.     case 6: sprintf(teste, "%s", fib.fib_Comment); break;
  2384.   }
  2385.   return teste;
  2386. }
  2387.  
  2388. int Conectado(void)
  2389. {
  2390.   /*
  2391.   Comando para testar se o micro esta usando a library que
  2392.   conecta a web.
  2393.  
  2394.   Versao  : 1.0
  2395.   Compila : AmigaDos
  2396.   Entrada : Sem necessidade
  2397.   Saida   : 0 se conectado, e -1 se nao conectado.
  2398.             x = Conectado();
  2399.   */
  2400.     
  2401.   struct Library *SocketBase;
  2402.   if(!(SocketBase = OpenLibrary("socket.library", 0)))
  2403.     return 0;
  2404.   CloseLibrary(SocketBase);
  2405.   return -1;
  2406. }
  2407.  
  2408. int ContaStrings(char *frase, char *string)
  2409. {
  2410.     /*
  2411.   Este comando conta quantas vezes uma determinada string
  2412.   esta presente em uma outra string.
  2413.  
  2414.     Entrada : Frase             --> Cristian Robert Gallas (CHAR*)
  2415.             String a procurar --> "is" (CHAR*)
  2416.     Saida   : Numero de ocorrencias --> 1 (INT)
  2417.             x = ContaStrings("Cristian Robert Gallas", "is");
  2418.     */
  2419.  
  2420.   char *tmp;
  2421.   int x = 0;
  2422.  
  2423.   tmp = malloc(strlen(frase));
  2424.   strcpy(tmp, frase);
  2425.  
  2426.   if(!strcmp(tmp, "") || !strcmp(string, ""))
  2427.     return 0;
  2428.  
  2429.   while(strstr(tmp, string))
  2430.   {
  2431.     x++;
  2432.     strcpy(tmp, strstr(tmp, string));
  2433.     strcpy(tmp, Copia(tmp, (strlen(string) + 1), 1000));
  2434.   }
  2435.   free(tmp);
  2436.   return x;
  2437. }
  2438.  
  2439. char *SubstituiString(char *frase, char *str1, char *str2)
  2440. {
  2441.   /* Comando para substituir strings dentro de outra string.
  2442.  
  2443.   Versao  : 1.0
  2444.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2445.   Entrada : Texto principal     --> "CristianGallas" (CHAR*)
  2446.             String a substituir --> "tian" (CHAR*)
  2447.             String nova         --> "XX" (CHAR*)
  2448.   Saida   : String principal alterada
  2449.             "CrisXXGallas" (CHAR*)
  2450.             SubstituiString("CristianGallas", "tian", "XX");
  2451.   */
  2452.  
  2453.   char *saida, *parte1, *parte2, *tmp;
  2454.   int x = 0, frasefinal = 0;
  2455.  
  2456.   if(!strcmp(frase, "") || !strcmp(str1, ""))
  2457.     return frase;
  2458.  
  2459.   /* CALCULA O TAMANHO FINAL DA STRING PARA ALOCAR MEMORIA */
  2460.   x          = ContaStrings(frase, str1);
  2461.   frasefinal = (strlen(frase) - (strlen(str1) * x) + (strlen(str2) * x));
  2462.   frasefinal = frasefinal * 2;
  2463.  
  2464.   saida  = malloc(frasefinal);
  2465.   parte1 = malloc(frasefinal);
  2466.   parte2 = malloc(frasefinal);
  2467.   tmp    = malloc(frasefinal);
  2468.  
  2469.   strcpy(tmp, frase);
  2470.   strcpy(saida, frase);
  2471.   while(strstr(saida, str1))
  2472.   {
  2473.     strcpy(tmp, strstr(saida, str1));
  2474.     strcpy(parte1, Copia(saida, 1, (strlen(saida) - strlen(tmp))));
  2475.     strcpy(parte2, Copia(tmp, (strlen(str1) + 1), 1000));
  2476.     sprintf(tmp, "%s%s%s", parte1, str2, parte2);
  2477.     strcpy(saida, tmp);
  2478.   }
  2479.   strcpy(saida, tmp);
  2480.   free(parte1); free(parte2); free(tmp);
  2481.   return saida;
  2482. }
  2483.  
  2484. char *CortaStringArquivo(char *arq, char *str1, char *str2, int vezes)
  2485. {
  2486.   /*
  2487.   Comando abre um arquivo txt e corta determinado texto de dentro
  2488.   dele, delimitando inicio e fim do corte, inicio da string a achar
  2489.   e cortar ate o inicio da outra string.
  2490.  
  2491.   Versao  : 1.0
  2492.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2493.   Entrada : Arquivo Texto    --> "ram:crg.txt" (CHAR*)
  2494.             String inicial   --> "Cristian" (CHAR*)
  2495.             String final     --> "Gallas" (CHAR*)
  2496.             Nr string no txt --> 2
  2497.             Esse numero permite o pulo de strings iniciais,
  2498.             exemplo, pegar determinado txt entre a segunda string
  2499.             inicial e a final.
  2500.   Saida   : Conteudo que existe entre a string inicial e a final
  2501.             nao sera pego as strings delimitadoras
  2502.             CortaFileString("ram:crg.txt", "Cristian", "Gallas", 2);
  2503.   */
  2504.  
  2505.   char *teste, *tmp, a;
  2506.   int x = 0;
  2507.     FILE *entrada;
  2508.  
  2509.   if(!(entrada = fopen(arq, "r")))
  2510.     return "ERROR";
  2511.  
  2512.   teste = malloc(atoi(ExaminaArquivo(arq, 0)) + 1);
  2513.   tmp   = malloc(atoi(ExaminaArquivo(arq, 0)) + 1);
  2514.  
  2515.   x = 0;
  2516.   while(a = getc(entrada),! feof(entrada))
  2517.     teste[x++] = a;
  2518.   teste[x] = '\0';
  2519.   fclose(entrada);
  2520.  
  2521.   if(!strstr(teste, str1)) {
  2522.     return teste; }
  2523.  
  2524.   for(x = 0; x < vezes; x++) {
  2525.         strcpy(teste, strstr(teste, str1));
  2526.     teste[0] = 'X'; }
  2527.  
  2528.   tmp = strstr(teste, str2);
  2529.   *tmp = '\0';
  2530.  
  2531.   strcpy(teste, Copia(teste, strlen(str1) + 1, -1));
  2532.   return teste;
  2533. }
  2534.